@gftdcojp/actor-sdk/dist/index.d.ts

Comprehensive TypeScript SDK for GFTD Actor Platform with Well-becoming Agent as default - Supporting mental wellness and personal growth through AI

import { Document } from '@langchain/core/documents';
import { NextRequest, NextResponse } from 'next/server';
import LightningFS from '@isomorphic-git/lightning-fs';
import { ClassValue } from 'clsx';

/**
 * Actor v3 API型定義
 * プロセス代数とLangChain.js互換性
 * https://actor.gftd.ai/api/v3/actor
 */
type ActorID = string;
interface Message {
    id: string;
    label: string;
    payload: Record<string, any>;
    timestamp: string;
    sender?: ActorID;
}
interface State {
    [key: string]: any;
}
interface OutAction {
    type: 'send' | 'spawn' | 'terminate';
    target?: ActorID;
    message?: Message;
    behavior?: Behavior;
}
interface BehaviorResult {
    new_state: State;
    actions: OutAction[];
    error?: string;
}
interface Behavior {
    id: string;
    name: string;
    description: string;
    version: string;
    handler: (message: Message, state: State) => Promise<BehaviorResult>;
    metadata: {
        created_at: string;
        updated_at: string;
        author: string;
        tags: string[];
        capabilities: string[];
    };
    process_algebra: {
        notation: 'CCS' | 'π-calculus' | 'ACP';
        expression: string;
        channels: string[];
    };
}
interface CreateActorRequest {
    behavior: Behavior;
    organization_id: string;
    initial_state?: State;
}
interface CreateActorResponse {
    actor_id: ActorID;
    status: 'created';
    timestamp: string;
}
interface SendMessageRequest {
    target: ActorID;
    message: Omit<Message, 'id' | 'timestamp'>;
}
interface SendMessageResponse {
    message_id: string;
    status: 'sent';
    timestamp: string;
}
interface ReceiveMessagesRequest {
    max_messages?: number;
    timeout?: number;
    filter?: {
        labels?: string[];
        sender?: ActorID;
    };
}
interface ReceiveMessagesResponse {
    messages: Message[];
    behavior_results: BehaviorResult[];
    timestamp: string;
}
interface ListActorsResponse {
    actors: {
        actor_id: ActorID;
        behavior_name: string;
        status: 'active' | 'inactive' | 'terminated';
        created_at: string;
    }[];
    total_count: number;
}
interface ActorSystemConfig {
    process_algebra_analysis: {
        deadlock_free: boolean;
        livelock_free: boolean;
        deadlock_actors?: ActorID[];
        livelock_patterns?: string[];
    };
    communication_topology: {
        edges: {
            from: ActorID;
            to: ActorID;
            channel: string;
            weight: number;
        }[];
    };
}
interface SystemStatsResponse {
    stats: {
        active_actors: number;
        total_messages: number;
        average_latency_ms: number;
    };
    detailed_metrics: {
        performance_metrics: {
            throughput: number;
            latency_p95: number;
        };
    };
}
interface LangChainMessage {
    role: "user" | "assistant" | "system";
    content: string;
    name?: string;
    function_call?: any;
}
interface RunnableConfig$1 {
    timeout?: number;
    maxMessages?: number;
}
interface ActorV3RunnableInterface {
    invoke(input: any, config?: RunnableConfig$1): Promise<any>;
    stream(input: any, config?: RunnableConfig$1): AsyncGenerator<any, any, unknown>;
    batch(inputs: any[], config?: RunnableConfig$1): Promise<any[]>;
    pipe<T>(next: T): T;
    withFallbacks(fallbacks: any[]): any;
}
declare function createMessage(label: string, payload: Record<string, any>, sender?: ActorID): Message;
declare function langChainToActorV3(lcMsg: LangChainMessage): Message;
declare function actorV3ToLangChain(actorMsg: Message): LangChainMessage;
interface ActorV3Error {
    code: string;
    message: string;
    details?: Record<string, any>;
}
interface ApiV3Response<T> {
    success: boolean;
    data?: T;
    error?: ActorV3Error;
}

/**
 * LangChain.js互換の型定義
 * OpenAPI仕様に基づくMessageLike、RunnableConfig等
 */
/**
 * LangChain.js MessageLike型定義
 */
type MessageLike = HumanMessage | AIMessage | SystemMessage | ToolMessage;
interface HumanMessage {
    type: "human";
    content: string;
    additional_kwargs?: Record<string, any>;
    name?: string;
    id?: string;
}
interface AIMessage {
    type: "ai";
    content: string;
    tool_calls?: ToolCall[];
    additional_kwargs?: Record<string, any>;
    response_metadata?: Record<string, any>;
    name?: string;
    id?: string;
}
interface SystemMessage {
    type: "system";
    content: string;
    additional_kwargs?: Record<string, any>;
    name?: string;
    id?: string;
}
interface ToolMessage {
    type: "tool";
    content: string;
    tool_call_id: string;
    artifact?: Record<string, any>;
    additional_kwargs?: Record<string, any>;
    name?: string;
    id?: string;
}
interface ToolCall {
    id: string;
    name: string;
    args: Record<string, any>;
    type: "tool_call";
}
interface StructuredTool {
    name: string;
    description: string;
    schema: Record<string, any>;
}
/**
 * LangChain.js RunnableConfig型定義
 */
interface RunnableConfig {
    tags?: string[];
    metadata?: Record<string, any>;
    callbacks?: any[];
    recursion_limit?: number;
    max_concurrency?: number;
    run_name?: string;
    run_id?: string;
    configurable?: Record<string, any>;
}
/**
 * Runnable実行リクエスト型定義
 */
type RunnableInput = string | MessageLike | MessageLike[];
interface InvokeRequest {
    input: RunnableInput;
    config?: RunnableConfig;
}
interface StreamRequest {
    input: RunnableInput;
    config?: RunnableConfig;
}
interface BatchRequest {
    inputs: RunnableInput[];
    config?: RunnableConfig;
    max_concurrency?: number;
}
/**
 * Runnable実行レスポンス型定義
 */
interface InvokeResponse {
    output: MessageLike;
    metadata: {
        run_id: string;
        session_id?: string;
        usage?: {
            prompt_tokens?: number;
            completion_tokens?: number;
            total_tokens?: number;
        };
        execution_time: number;
    };
}
interface BatchResponse {
    outputs: InvokeResponse[];
    metadata: {
        batch_id: string;
        total_executions: number;
        successful_executions: number;
        failed_executions: number;
        execution_time: number;
    };
}
/**
 * エラーレスポンス型定義
 */
interface ErrorResponse {
    error: {
        code: string;
        message: string;
        type: "invalid_request_error" | "authentication_error" | "permission_error" | "not_found_error" | "rate_limit_error" | "api_error";
        param?: string;
        details?: Record<string, any>;
    };
}

/**
 * Actor セッション管理の型定義
 * OpenAPI仕様に基づくLangChain.js互換のSessionRunnable
 */

/**
 * LangChain.js互換のSessionRunnable型定義
 */
interface SessionRunnable {
    /** Session ID */
    id: string;
    /** Actor ID */
    actor_id: string;
    /** Session name */
    name: string;
    /** Session type - 固定値 "session" */
    type: "session";
    /** LangChain.js namespace */
    lc_namespace: string[];
    /** LangChain.js serializable flag */
    lc_serializable: boolean;
    /** Session configuration */
    config: SessionConfig;
    /** Session messages */
    messages: MessageLike[];
    /** Session state */
    state: Record<string, any>;
    /** Creation timestamp */
    created_at: string;
    /** Update timestamp */
    updated_at: string;
    /** Session metadata */
    metadata?: Record<string, any>;
}
interface ActorSession {
    /** Session ID (Git branch name) */
    id: string;
    /** Actor ID (repository_name with UUID) */
    actor_id: string;
    created_at: string;
    updated_at: string;
    status: "active" | "completed" | "failed" | "paused";
    metadata?: Record<string, any>;
    last_message_id?: string;
    message_count: number;
}
interface ActorMessage {
    id: string;
    session_id: string;
    role: "user" | "assistant" | "system";
    content: string | Record<string, any>;
    created_at: string;
    metadata?: Record<string, any>;
    tool_calls?: ActorToolCall[];
    function_call?: ActorFunctionCall;
}
interface ActorToolCall {
    id: string;
    type: "function";
    function: {
        name: string;
        arguments: string;
    };
}
interface ActorFunctionCall {
    name: string;
    arguments: string;
}
/**
 * OpenAPI仕様に基づくCreateSessionRequest
 */
interface CreateSessionRequest {
    name: string;
    branch?: string;
    parent_branch?: string;
    description?: string;
    config?: SessionConfig;
}
interface SessionCreateRequest {
    /** Actor ID (repository_name with UUID) */
    actor_id: string;
    metadata?: Record<string, any>;
    initial_message?: {
        content: string | Record<string, any>;
        metadata?: Record<string, any>;
    };
}
interface SessionContinueRequest {
    /** Session ID (Git branch name) */
    session_id: string;
    message: {
        content: string | Record<string, any>;
        metadata?: Record<string, any>;
    };
}
interface SessionResponse {
    session: ActorSession;
    messages: ActorMessage[];
    has_more: boolean;
}
interface MessageResponse {
    message: ActorMessage;
    session: ActorSession;
    next_messages?: ActorMessage[];
}
interface SessionListResponse {
    sessions: ActorSession[];
    total: number;
    page: number;
    limit: number;
    has_next: boolean;
    has_previous: boolean;
}
interface SessionStreamEvent {
    type: "message" | "message_delta" | "session_update" | "error" | "done";
    data: any;
}
interface SessionStreamResponse {
    event: SessionStreamEvent;
    session_id: string;
    message_id?: string;
}
/**
 * OpenAPI仕様に基づくSessionConfig
 */
interface SessionConfig {
    max_iterations?: number;
    memory_window?: number;
    auto_save?: boolean;
    branch?: string;
    parent_session?: string;
}
interface SessionError {
    code: string;
    message: string;
    session_id?: string;
    details?: Record<string, any>;
}

/**
 * @file lib/git/git-fs.ts
 * @description isomorphic-gitを使用したGitファイルシステム
 * @author GFTD Co., Ltd.
 */
/**
 * Git設定インターフェース
 */
interface GitConfig {
    /** リポジトリURL */
    url: string;
    /** Personal Access Token */
    token: string;
    /** 作成者情報 */
    author: {
        name: string;
        email: string;
    };
    /** ブランチ名 */
    branch?: string;
    /** ローカルディレクトリ名 */
    dir?: string;
}
/**
 * GitFileSystemクラス
 * isomorphic-gitを使用してGitリポジトリをファイルシステムとして操作
 */
declare class GitFileSystem {
    private fs;
    private config;
    private dir;
    private currentBranch;
    private isInitialized;
    constructor(config: GitConfig);
    /**
     * ディレクトリを再帰的に作成
     */
    private ensureDir;
    /**
     * リポジトリを初期化またはクローン
     */
    initialize(): Promise<void>;
    /**
     * リポジトリをクローン
     */
    private clone;
    /**
     * 新しいリポジトリを初期化
     */
    private init;
    /**
     * ブランチを切り替え
     * @param branchName ブランチ名
     * @param createIfNotExists 存在しない場合は作成
     */
    switchBranch(branchName: string, createIfNotExists?: boolean): Promise<void>;
    /**
     * ファイルを書き込み
     * @param filePath ファイルパス
     * @param content ファイル内容
     */
    writeFile(filePath: string, content: string): Promise<void>;
    /**
     * ファイルを読み込み
     * @param filePath ファイルパス
     * @returns ファイル内容
     */
    readFile(filePath: string): Promise<string>;
    /**
     * ファイルを削除
     * @param filePath ファイルパス
     */
    deleteFile(filePath: string): Promise<void>;
    /**
     * ディレクトリの内容を一覧取得
     * @param dirPath ディレクトリパス
     * @returns ファイル・ディレクトリ一覧
     */
    readDir(dirPath?: string): Promise<string[]>;
    /**
     * ファイルが存在するかチェック
     * @param filePath ファイルパス
     * @returns 存在するかどうか
     */
    exists(filePath: string): Promise<boolean>;
    /**
     * 変更をコミット
     * @param message コミットメッセージ
     * @param filePaths コミットするファイルパス（空の場合は全て）
     */
    commit(message: string, filePaths?: string[]): Promise<string>;
    /**
     * リモートにプッシュ
     */
    push(): Promise<void>;
    /**
     * リモートからプル
     */
    pull(): Promise<void>;
    /**
     * ブランチ一覧を取得
     * @returns ブランチ一覧
     */
    listBranches(): Promise<string[]>;
    /**
     * 現在のブランチを取得
     * @returns 現在のブランチ名
     */
    getCurrentBranch(): string;
    /**
     * コミット履歴を取得
     * @param depth 取得する履歴の深さ
     * @returns コミット履歴
     */
    getCommitHistory(depth?: number): Promise<any[]>;
    /**
     * 作業ディレクトリの状態を取得
     * @returns ファイルの状態一覧
     */
    getStatus(): Promise<any[]>;
    /**
     * ファイルの状態を判定
     */
    private getFileStatus;
    /**
     * リソースのクリーンアップ
     */
    cleanup(): Promise<void>;
}

/**
 * @file lib/types/chat-git.ts
 * @description チャット履歴のGit保存機能に関する型定義
 * @author GFTD Co., Ltd.
 */

/**
 * チャット履歴のGit保存設定
 */
interface ChatGitConfig {
    /** Git設定 */
    git: GitConfig;
    /** 保存形式 */
    format: 'markdown' | 'json' | 'both';
    /** 自動コミット */
    autoCommit: boolean;
    /** コミットメッセージのテンプレート */
    commitMessageTemplate?: string;
    /** ファイル保存のディレクトリ */
    baseDirectory?: string;
}
/**
 * チャット履歴ファイルのメタデータ
 */
interface ChatHistoryMetadata {
    /** セッションID */
    sessionId: string;
    /** アクターID */
    actorId: string;
    /** セッション作成日時 */
    createdAt: string;
    /** 最終更新日時 */
    updatedAt: string;
    /** メッセージ数 */
    messageCount: number;
    /** ファイル形式 */
    format: 'markdown' | 'json' | 'both';
    /** Gitコミットハッシュ */
    commitSha?: string;
    /** ブランチ名 */
    branch: string;
}
/**
 * チャット履歴のファイル構造
 */
interface ChatHistoryFile {
    /** メタデータ */
    metadata: ChatHistoryMetadata;
    /** セッション情報 */
    session: ActorSession;
    /** メッセージ履歴 */
    messages: ActorMessage[];
    /** 追加情報 */
    additionalInfo?: Record<string, any>;
}
/**
 * Git保存結果
 */
interface ChatGitSaveResult {
    /** 成功フラグ */
    success: boolean;
    /** コミットハッシュ */
    commitSha?: string;
    /** 保存されたファイルパス */
    filePaths: string[];
    /** エラーメッセージ */
    error?: string;
}
/**
 * チャット履歴検索条件
 */
interface ChatHistorySearchQuery {
    /** セッションID */
    sessionId?: string;
    /** アクターID */
    actorId?: string;
    /** 日付範囲（開始） */
    dateFrom?: string;
    /** 日付範囲（終了） */
    dateTo?: string;
    /** メッセージ内容のキーワード */
    keyword?: string;
    /** ブランチ名 */
    branch?: string;
    /** 最大結果数 */
    limit?: number;
}
/**
 * チャット履歴検索結果
 */
interface ChatHistorySearchResult {
    /** 履歴ファイル */
    historyFile: ChatHistoryFile;
    /** マッチしたメッセージのインデックス */
    matchedMessageIndices?: number[];
    /** スコア（検索の関連度） */
    score?: number;
    /** ファイルパス */
    filePath: string;
}
/**
 * チャット履歴のGit操作インターフェース
 */
interface IChatGitManager {
    /**
     * チャット履歴を保存
     * @param session セッション情報
     * @param messages メッセージ履歴
     * @param commitMessage コミットメッセージ
     */
    saveHistory(session: ActorSession, messages: ActorMessage[], commitMessage?: string): Promise<ChatGitSaveResult>;
    /**
     * チャット履歴を読み込み
     * @param sessionId セッションID
     * @param branch ブランチ名
     */
    loadHistory(sessionId: string, branch?: string): Promise<ChatHistoryFile | null>;
    /**
     * チャット履歴を検索
     * @param query 検索条件
     */
    searchHistory(query: ChatHistorySearchQuery): Promise<ChatHistorySearchResult[]>;
    /**
     * メッセージを追加保存
     * @param sessionId セッションID
     * @param newMessages 新しいメッセージ
     * @param commitMessage コミットメッセージ
     */
    appendMessages(sessionId: string, newMessages: ActorMessage[], commitMessage?: string): Promise<ChatGitSaveResult>;
    /**
     * セッションのブランチを作成
     * @param sessionId セッションID
     * @param branchName ブランチ名
     * @param baseBranch ベースブランチ
     */
    createSessionBranch(sessionId: string, branchName: string, baseBranch?: string): Promise<boolean>;
    /**
     * 履歴のGitステータス取得
     * @param sessionId セッションID
     */
    getHistoryStatus(sessionId: string): Promise<{
        hasChanges: boolean;
        lastCommitSha?: string;
        lastCommitMessage?: string;
        branch: string;
    }>;
    /**
     * コミット履歴取得
     * @param sessionId セッションID
     * @param limit 件数制限
     */
    getCommitHistory(sessionId: string, limit?: number): Promise<{
        commitSha: string;
        message: string;
        author: string;
        date: string;
        messageCount: number;
    }[]>;
}
/**
 * チャット履歴のファイル命名規則
 */
interface ChatHistoryFileNaming {
    /** セッションディレクトリのパターン */
    sessionDirPattern: string;
    /** Markdownファイル名のパターン */
    markdownFilePattern: string;
    /** JSONファイル名のパターン */
    jsonFilePattern: string;
    /** メタデータファイル名のパターン */
    metadataFilePattern: string;
}
/**
 * Markdownエクスポート設定
 */
interface MarkdownExportOptions {
    /** タイトル形式 */
    titleFormat: string;
    /** メッセージ形式 */
    messageFormat: string;
    /** タイムスタンプ形式 */
    timestampFormat: string;
    /** 目次を含める */
    includeToc: boolean;
    /** メタデータを含める */
    includeMetadata: boolean;
}

/**
 * @file lib/types/config.ts
 * @description Actor SDK Config 設定システム
 * @author GFTD Co., Ltd.
 */

/**
 * GFTD認証設定
 */
interface GFTDAuthConfig {
    /** 認証必須かどうか */
    required?: boolean;
    /** 認証サーバーURL */
    authUrl?: string;
    /** 認証APIキー */
    apiKey?: string;
    /** 認証トークンの有効期限 (秒) */
    tokenExpiry?: number;
    /** 認証プロバイダー */
    provider?: 'gftd' | 'custom';
    /** 認証スコープ */
    scopes?: string[];
    /** 自動リフレッシュ設定 */
    autoRefresh?: boolean;
    /** リダイレクトURL */
    redirectUrl?: string;
}
/**
 * ツール機能設定
 */
interface ToolsConfig {
    /** Actor管理機能 */
    actorManagement: boolean;
    /** セッション管理機能 */
    sessionManagement: boolean;
    /** ストリーミング機能 */
    streaming: boolean;
    /** Embedding & Vector Search機能 */
    embedding: boolean;
    /** Git統合機能 */
    gitIntegration: boolean;
    /** チャット履歴Git管理 */
    chatGitManagement: boolean;
    /** モニタリング & アナリティクス */
    monitoring: boolean;
    /** React UI コンポーネント */
    uiComponents: boolean;
}
/**
 * Actor API設定
 */
interface ActorApiConfig {
    /** API ベース URL */
    baseUrl: string;
    /** API キー */
    apiKey?: string;
    /** タイムアウト設定 (秒) */
    timeout?: number;
    /** リトライ回数 */
    retryCount?: number;
    /** リクエストヘッダー */
    headers?: Record<string, string>;
}
/**
 * Embedding設定
 */
interface EmbeddingConfig$1 {
    /** モデル名 */
    modelName?: string;
    /** ベクトル次元数 */
    dimensions?: number;
    /** キャッシュディレクトリ */
    cacheDir?: string;
    /** バッチサイズ */
    batchSize?: number;
}
/**
 * Git統合設定
 */
interface GitIntegrationConfig {
    /** GitLab設定 */
    gitlab?: {
        url: string;
        token: string;
        defaultVisibility?: 'private' | 'internal' | 'public';
    };
    /** Git作成者情報 */
    author?: {
        name: string;
        email: string;
    };
    /** 自動コミット設定 */
    autoCommit?: boolean;
    /** 自動プッシュ設定 */
    autoPush?: boolean;
    /** デフォルトブランチ名 */
    defaultBranch?: string;
}
/**
 * ストリーミング設定
 */
interface StreamingConfig {
    /** ストリーミング有効化 */
    enabled: boolean;
    /** チャンクサイズ */
    chunkSize?: number;
    /** タイムアウト設定 (秒) */
    timeout?: number;
    /** 再接続設定 */
    reconnect?: {
        enabled: boolean;
        maxAttempts?: number;
        interval?: number;
    };
}
/**
 * モニタリング設定
 */
interface MonitoringConfig {
    /** メトリクス収集 */
    metricsEnabled: boolean;
    /** ログレベル */
    logLevel?: 'debug' | 'info' | 'warn' | 'error';
    /** パフォーマンス追跡 */
    performanceTracking?: boolean;
    /** エラー自動レポート */
    errorReporting?: boolean;
}
/**
 * UI設定
 */
interface UIConfig {
    /** テーマ */
    theme?: 'light' | 'dark' | 'auto';
    /** 言語設定 */
    locale?: string;
    /** デフォルトページサイズ */
    defaultPageSize?: number;
    /** アニメーション有効化 */
    animations?: boolean;
    /** カスタムCSS */
    customStyles?: string;
}
/**
 * デバッグ設定
 */
interface DebugConfig {
    /** デバッグモード */
    enabled: boolean;
    /** 詳細ログ */
    verboseLogging?: boolean;
    /** API呼び出しログ */
    logApiCalls?: boolean;
    /** Git操作ログ */
    logGitOperations?: boolean;
    /** パフォーマンス計測 */
    measurePerformance?: boolean;
}
/**
 * Actor SDK 包括的設定
 */
interface ActorSDKConfig {
    /** 有効化するtools */
    tools: ToolsConfig;
    /** Actor API設定 */
    api: ActorApiConfig;
    /** GFTD認証設定 */
    auth?: GFTDAuthConfig;
    /** セッション管理のデフォルト設定 */
    session?: SessionConfig;
    /** Embedding設定 */
    embedding?: EmbeddingConfig$1;
    /** Git統合設定 */
    git?: GitIntegrationConfig;
    /** チャット履歴Git管理設定 */
    chatGit?: ChatGitConfig;
    /** ストリーミング設定 */
    streaming?: StreamingConfig;
    /** モニタリング設定 */
    monitoring?: MonitoringConfig;
    /** UI設定 */
    ui?: UIConfig;
    /** デバッグ設定 */
    debug?: DebugConfig;
    /** カスタム設定 */
    custom?: Record<string, any>;
}
/**
 * デフォルト設定を生成
 */
declare function createDefaultConfig(): ActorSDKConfig;
/**
 * 開発環境用設定を生成
 */
declare function createDevelopmentConfig(): ActorSDKConfig;
/**
 * プロダクション環境用設定を生成
 */
declare function createProductionConfig(): ActorSDKConfig;
/**
 * 設定をマージ
 */
declare function mergeConfig(...configs: Partial<ActorSDKConfig>[]): ActorSDKConfig;
/**
 * 設定の検証
 */
declare function validateConfig(config: ActorSDKConfig): {
    valid: boolean;
    errors: string[];
};
/**
 * 設定が有効かチェック
 */
declare function isToolEnabled(config: ActorSDKConfig, tool: keyof ToolsConfig): boolean;
/**
 * 環境変数から設定を生成
 */
declare function createConfigFromEnv(): Partial<ActorSDKConfig>;
/**
 * 開発環境設定を生成（統一されたAPIエンドポイント使用）
 */
declare function createLocalDevelopmentConfig(organizationId?: string): ActorSDKConfig;
/**
 * 環境判定: 開発環境かどうか
 */
declare function isLocalDevelopment(): boolean;
/**
 * GitLabデフォルト設定付きSDK設定を生成
 */
declare function createConfigWithDefaultGitLab(overrides?: Partial<ActorSDKConfig>): ActorSDKConfig;

/**
 * Actor v3 APIクライアント
 * プロセス代数とLangChain.js互換性対応
 * https://actor.gftd.ai/api/v3/actor
 */

/**
 * Actor v3 メインクライアント
 */
declare class ActorV3Client {
    private baseUrl;
    private apiKey?;
    constructor(config?: {
        apiKey?: string;
        baseUrl?: string;
    });
    private request;
    /**
     * アクター管理API
     */
    actors: {
        /**
         * 新しいアクターを作成
         */
        create: (request: CreateActorRequest) => Promise<ApiV3Response<CreateActorResponse>>;
        /**
         * アクター一覧を取得
         */
        list: (organizationId?: string) => Promise<ApiV3Response<ListActorsResponse>>;
        /**
         * アクターにメッセージを送信
         */
        send: (actorId: ActorID, request: SendMessageRequest) => Promise<ApiV3Response<SendMessageResponse>>;
        /**
         * アクターからメッセージを受信
         */
        receive: (actorId: ActorID, request?: ReceiveMessagesRequest) => Promise<ApiV3Response<ReceiveMessagesResponse>>;
        /**
         * アクターを削除
         */
        delete: (actorId: ActorID) => Promise<ApiV3Response<{
            status: "deleted";
        }>>;
    };
    /**
     * システム管理API
     */
    system: {
        /**
         * システム設定を取得（プロセス代数分析含む）
         */
        getConfig: () => Promise<ApiV3Response<ActorSystemConfig>>;
        /**
         * システム統計を取得
         */
        getStats: () => Promise<ApiV3Response<SystemStatsResponse>>;
    };
}
/**
 * LangChain.js互換性ラッパー
 */
declare class ActorV3Runnable {
    private actorId;
    private client;
    constructor(actorId: ActorID, client: ActorV3Client);
    /**
     * LangChain.js invoke() 互換メソッド
     */
    invoke(input: any, config?: RunnableConfig$1): Promise<any>;
    /**
     * LangChain.js stream() 互換メソッド
     */
    stream(input: any, config?: RunnableConfig$1): AsyncGenerator<any, any, unknown>;
    /**
     * LangChain.js batch() 互換メソッド
     */
    batch(inputs: any[], config?: RunnableConfig$1): Promise<any[]>;
    /**
     * LangChain.js pipe() 互換メソッド
     */
    pipe<T>(next: T): T;
    /**
     * LangChain.js withFallbacks() 互換メソッド
     */
    withFallbacks(fallbacks: any[]): ActorV3Runnable;
}
/**
 * デフォルトクライアントインスタンス
 */
declare const actorV3Api: ActorV3Client;
/**
 * サンプルBehavior作成ヘルパー
 */
declare function createSampleBehavior(name: string, description: string): Behavior;

/**
 * Actor v3 LangChain Chat API クライアント
 * https://api.actor.gftd.ai/v3/langchain/actor を使用したチャット機能を提供
 */
interface ChatMessage {
    id: string;
    role: "user" | "assistant" | "system";
    content: string;
    timestamp: Date;
}
interface LangChainActorConfig {
    name: string;
    description?: string;
    model?: "gpt-4o" | "gpt-4o-mini" | "gpt-4-turbo" | "gpt-4" | "gpt-3.5-turbo";
    temperature?: number;
    max_tokens?: number;
    system_prompt?: string;
    organization_id: string;
    openai_api_key?: string;
    max_history_length?: number;
    actor_id?: string;
}
interface LangChainActorResponse {
    actor_id: string;
    actor: any;
    config: LangChainActorConfig;
    endpoints: {
        chat: string;
        system_prompt: string;
        config_update: string;
        stats: string;
    };
}
interface ChatRequest {
    message: string;
    conversation_id?: string;
    timeout?: number;
    stream?: boolean;
}
interface ChatResponse {
    content: string;
    usage: {
        total_tokens: number;
        prompt_tokens: number;
        completion_tokens: number;
    };
    model: string;
    conversation_id: string;
    execution_time_ms: number;
    timestamp: string;
}
/**
 * Actor v3 LangChain Chat API クライアントクラス
 * Actor v3のLangChain統合機能を使用したチャット機能を提供
 */
declare class ActorV3ChatClient {
    private baseUrl;
    private headers;
    private organizationId;
    private currentActorId;
    constructor(baseUrl?: string, organizationId?: string, apiKey?: string);
    /**
     * LangChain Actor を作成
     * @param config LangChain Actor設定
     * @returns LangChain Actor作成レスポンス
     */
    createLangChainActor(config: Partial<LangChainActorConfig>): Promise<LangChainActorResponse>;
    /**
     * チャットメッセージを送信
     * @param actorId Actor ID
     * @param request チャットリクエスト
     * @returns チャットレスポンス
     */
    sendChatMessage(actorId: string, request: ChatRequest): Promise<ChatResponse>;
    /**
     * 現在のActorでチャット（簡易版）
     * @param message メッセージ内容
     * @param conversationId 会話ID（オプション）
     * @returns チャットレスポンス
     */
    chat(message: string, conversationId?: string): Promise<ChatResponse>;
    /**
     * システムプロンプトを更新
     * @param actorId Actor ID
     * @param systemPrompt 新しいシステムプロンプト
     */
    updateSystemPrompt(actorId: string, systemPrompt: string): Promise<void>;
    /**
     * APIの健全性をチェック
     * @returns APIが利用可能かどうか
     */
    healthCheck(): Promise<boolean>;
    /**
     * 現在のActor IDを取得
     * @returns 現在のActor ID
     */
    getCurrentActorId(): string | null;
    /**
     * Actor IDを手動設定
     * @param actorId 設定するActor ID
     */
    setCurrentActorId(actorId: string): void;
}
/**
 * デフォルトのActor v3 Chat APIクライアントインスタンス
 */
declare const actorV3ChatClient: ActorV3ChatClient;

/**
 * Actor v3 一覧管理Hook
 */
declare function useActorV3List(organizationId?: string): {
    actors: {
        actor_id: ActorID;
        behavior_name: string;
        status: "active" | "inactive" | "terminated";
        created_at: string;
    }[];
    loading: boolean;
    error: string | null;
    totalCount: number;
    refetch: () => void;
};
/**
 * Actor v3 作成Hook
 */
declare function useActorV3Creation(): {
    createActor: (behavior: Behavior, organizationId: string, initialState?: State) => Promise<CreateActorResponse | null>;
    createSampleActor: (name: string, description: string, organizationId: string) => Promise<CreateActorResponse | null>;
    loading: boolean;
    error: string | null;
};
/**
 * Actor v3 メッセージング Hook
 */
declare function useActorV3Messaging(actorId: ActorID): {
    sendMessage: (label: string, payload: Record<string, any>, target?: ActorID) => Promise<SendMessageResponse | null | undefined>;
    receiveMessages: (request?: ReceiveMessagesRequest) => Promise<ReceiveMessagesResponse | null>;
    clearMessages: () => void;
    messages: Message[];
    loading: boolean;
    error: string | null;
};
/**
 * LangChain.js互換 Actor v3 Hook
 */
declare function useActorV3Runnable(actorId: ActorID): {
    runnable: ActorV3Runnable;
    invoke: (input: any, config?: any) => Promise<any>;
    batch: (inputs: any[], config?: any) => Promise<any[]>;
    loading: boolean;
    error: string | null;
};
/**
 * Actor v3 システム管理Hook
 */
declare function useActorV3System(): {
    config: ActorSystemConfig | null;
    stats: SystemStatsResponse | null;
    loading: boolean;
    error: string | null;
    fetchConfig: () => Promise<void>;
    fetchStats: () => Promise<void>;
    refreshAll: () => Promise<void>;
};
/**
 * Actor v3 ヘルスチェック Hook
 */
declare function useActorV3Health(): {
    status: "unknown" | "checking" | "healthy" | "unhealthy";
    lastChecked: string | null;
    error: string | null;
    checkHealth: () => Promise<void>;
};

/**
 * Actor v3 LangChain Chat API用Reactフック
 * Actor v3のLangChain統合を使用したチャット機能の状態管理とAPI呼び出しを提供
 */

interface UseGftdChatOptions {
    initialMessages?: ChatMessage[];
    model?: string;
    temperature?: number;
    maxTokens?: number;
}
interface UseGftdChatReturn {
    messages: ChatMessage[];
    isLoading: boolean;
    error: string | null;
    isConnected: boolean;
    sendMessage: (content: string) => Promise<void>;
    clearMessages: () => void;
    retryLastMessage: () => Promise<void>;
    setMessages: (messages: ChatMessage[]) => void;
}
/**
 * GFTD Chat APIを使用するためのカスタムフック
 * @param options チャット設定オプション
 * @returns チャット機能のインターフェース
 */
declare function useGftdChat(options?: UseGftdChatOptions): UseGftdChatReturn;

/**
 * @file lib/config/sdk-config-manager.ts
 * @description SDK起動時のconfigファイル管理
 * @author GFTD Co., Ltd.
 */
interface SDKConfig {
    version: string;
    initialized: boolean;
    defaultActorId?: string;
    actors: {
        [key: string]: {
            id: string;
            name: string;
            type: string;
            repositoryType: 'local' | 'online';
            repositoryPath: string;
            repositoryUrl?: string;
            gitConfig?: any;
            lastAccessed: string;
            isDefault?: boolean;
        };
    };
    settings: {
        theme: 'light' | 'dark';
        autoSave: boolean;
        showWelcome: boolean;
        defaultView: 'actors' | 'code' | 'preview';
    };
    created: string;
    lastModified: string;
}
/**
 * デフォルトアクター設定テンプレート
 */
interface DefaultActorTemplate {
    name: string;
    description: string;
    type: string;
    repositoryType: 'local';
    gitConfig: {
        user: {
            name: string;
            email: string;
        };
        remoteUrl?: string;
        defaultBranch: string;
        autoCommit: boolean;
        autoSync: boolean;
    };
}
/**
 * 利用可能なデフォルトアクタータイプ
 */
declare const DEFAULT_ACTOR_TEMPLATES: Record<string, DefaultActorTemplate>;
/**
 * デフォルトのSDK設定
 */
declare function createDefaultSDKConfig(): SDKConfig;
/**
 * SDK設定管理クラス
 */
declare class SDKConfigManager {
    private static readonly CONFIG_FILE_PATH;
    private static readonly LOCAL_STORAGE_KEY;
    /**
     * 実行環境がブラウザかチェック
     */
    private static isBrowser;
    /**
     * 実行環境がNode.jsかチェック
     */
    private static isNode;
    /**
     * configファイルが存在するかチェック
     */
    static hasConfig(): Promise<boolean>;
    /**
     * configファイルを読み込み
     */
    static loadConfig(): Promise<SDKConfig | null>;
    /**
     * configファイルを保存
     */
    static saveConfig(config: SDKConfig): Promise<boolean>;
    /**
     * configにアクターを追加
     */
    static addActor(actorData: {
        id: string;
        name: string;
        type: string;
        repositoryType: 'local' | 'online';
        repositoryPath: string;
        repositoryUrl?: string;
        gitConfig?: any;
    }): Promise<boolean>;
    /**
     * デフォルトアクターを設定
     */
    static setDefaultActor(actorId: string): Promise<boolean>;
    /**
     * アクターのアクセス時刻を更新
     */
    static updateActorAccess(actorId: string): Promise<boolean>;
    /**
     * 設定を更新
     */
    static updateSettings(settings: Partial<SDKConfig['settings']>): Promise<boolean>;
    /**
     * configを初期化済みにマーク
     */
    static markAsInitialized(): Promise<boolean>;
    /**
     * configを検証・マイグレーション
     */
    private static validateAndMigrateConfig;
    /**
     * configをリセット（開発用）
     */
    static resetConfig(): Promise<boolean>;
    /**
     * デバッグ情報を出力（ブラウザのコンソールに表示）
     */
    static debugConfig(): Promise<void>;
    /**
     * デフォルトアクターを作成
     */
    static createDefaultActor(template?: keyof typeof DEFAULT_ACTOR_TEMPLATES): Promise<{
        success: boolean;
        actorId?: string;
        error?: string;
    }>;
    /**
     * 初期セットアップ - デフォルトアクターと設定を作成
     */
    static performInitialSetup(actorTemplate?: keyof typeof DEFAULT_ACTOR_TEMPLATES): Promise<{
        success: boolean;
        config?: SDKConfig;
        error?: string;
    }>;
    /**
     * 利用可能なデフォルトアクタータイプのリストを取得
     */
    static getAvailableTemplates(): Array<{
        key: string;
        template: DefaultActorTemplate;
    }>;
}

/**
 * @file lib/git/gitlab-client.ts
 * @description GitLab API クライアント
 * @author GFTD Co., Ltd.
 */
/**
 * GitLab設定インターフェース
 */
interface GitLabConfig {
    /** GitLabのURL */
    url: string;
    /** Personal Access Token */
    token: string;
    /** デフォルトプロジェクトの可視性 */
    defaultVisibility?: 'private' | 'internal' | 'public';
}
/**
 * プロジェクト作成設定
 */
interface CreateProjectConfig {
    /** プロジェクト名 */
    name: string;
    /** 説明 */
    description?: string;
    /** 可視性 */
    visibility?: 'private' | 'internal' | 'public';
    /** 初期化設定 */
    initialize_with_readme?: boolean;
    /** デフォルトブランチ */
    default_branch?: string;
}
/**
 * ブランチ作成設定
 */
interface CreateBranchConfig {
    /** ブランチ名 */
    name: string;
    /** 基点となるブランチまたはコミット */
    ref: string;
}
/**
 * GitLab APIクライアント
 */
declare class GitLabClient {
    private client;
    private config;
    constructor(config: GitLabConfig);
    /**
     * 新しいプロジェクト（Actor）を作成
     * @param config プロジェクト作成設定
     * @returns プロジェクト情報
     */
    createActor(config: CreateProjectConfig): Promise<{
        id: number;
        name: string;
        description: string | undefined;
        clone_url: string;
        ssh_url: string;
        web_url: string;
        default_branch: string | undefined;
        created_at: string;
    }>;
    /**
     * プロジェクトを取得
     * @param projectId プロジェクトID
     * @returns プロジェクト情報
     */
    getActor(projectId: number | string): Promise<{
        id: number;
        name: string;
        description: string | undefined;
        clone_url: string;
        ssh_url: string;
        web_url: string;
        default_branch: string | undefined;
        created_at: string;
        updated_at: string;
    }>;
    /**
     * 新しいブランチ（Session）を作成
     * 概念: new session -> new_branch
     * @param projectId プロジェクトID
     * @param config ブランチ作成設定
     * @returns ブランチ情報
     */
    createSession(projectId: number | string, config: CreateBranchConfig): Promise<{
        name: string;
        commit: {
            id: unknown;
            message: unknown;
            author_name: unknown;
            author_email: unknown;
            created_at: unknown;
        };
        protected: boolean;
        can_push: boolean;
        web_url: string;
    }>;
    /**
     * ブランチ（Session）を取得
     * 概念: session = Git branch
     * @param projectId プロジェクトID
     * @param branchName ブランチ名（Session ID）
     * @returns ブランチ情報
     */
    getSession(projectId: number | string, branchName: string): Promise<{
        name: string;
        commit: {
            id: unknown;
            message: unknown;
            author_name: unknown;
            author_email: unknown;
            created_at: unknown;
        };
        protected: boolean;
        can_push: boolean;
        web_url: string;
    }>;
    /**
     * プロジェクトの全ブランチ（Sessions）を取得
     * 概念: sessions = Git branches
     * @param projectId プロジェクトID
     * @returns ブランチ一覧（Session一覧）
     */
    listSessions(projectId: number | string): Promise<{
        name: string;
        commit: {
            id: unknown;
            message: unknown;
            author_name: unknown;
            author_email: unknown;
            created_at: unknown;
        };
        protected: boolean;
        can_push: boolean;
        web_url: string;
    }[]>;
    /**
     * ブランチを削除
     * @param projectId プロジェクトID
     * @param branchName ブランチ名
     */
    deleteSession(projectId: number | string, branchName: string): Promise<boolean>;
    /**
     * プロジェクトを削除
     * @param projectId プロジェクトID
     */
    deleteActor(projectId: number | string): Promise<boolean>;
    /**
     * ファイルを作成または更新
     * @param projectId プロジェクトID
     * @param filePath ファイルパス
     * @param content ファイル内容
     * @param commitMessage コミットメッセージ
     * @param branch ブランチ名
     */
    createOrUpdateFile(projectId: number | string, filePath: string, content: string, commitMessage: string, branch?: string): Promise<any>;
    /**
     * ファイルを取得
     * @param projectId プロジェクトID
     * @param filePath ファイルパス
     * @param branch ブランチ名
     */
    getFile(projectId: number | string, filePath: string, branch?: string): Promise<any>;
    /**
     * ファイルを削除
     * @param projectId プロジェクトID
     * @param filePath ファイルパス
     * @param commitMessage コミットメッセージ
     * @param branch ブランチ名
     */
    deleteFile(projectId: number | string, filePath: string, commitMessage: string, branch?: string): Promise<any>;
    /**
     * リポジトリのファイル一覧を取得
     * @param projectId プロジェクトID
     * @param path パス（オプション）
     * @param branch ブランチ名
     */
    listFiles(projectId: number | string, path?: string, branch?: string): Promise<any[]>;
}

/**
 * @file lib/git/git-vector-store.ts
 * @description Git対応のベクトルストア
 * @author GFTD Co., Ltd.
 */

/**
 * Git対応ベクトルストアエントリー
 */
interface GitVectorStoreEntry {
    id: string;
    vector: number[];
    document: Document;
    timestamp: number;
    commitSha?: string;
}
/**
 * Git検索結果
 */
interface GitSearchResult {
    document: Document;
    score: number;
    id: string;
    commitSha?: string;
}
/**
 * Git対応のベクトルストアクラス
 * usearchとGitを組み合わせて、ベクトル検索データをGitリポジトリで管理
 */
declare class GitVectorStore {
    private index;
    private gitFs;
    private entries;
    private dimensions;
    private isInitialized;
    private vectorsDir;
    private metadataDir;
    private indexFile;
    constructor(gitFs: GitFileSystem, dimensions?: number);
    /**
     * ベクトルストアの初期化
     */
    initialize(): Promise<void>;
    /**
     * 必要なディレクトリを初期化
     */
    private initializeDirectories;
    /**
     * 既存のインデックスを読み込み
     */
    private loadExistingIndex;
    /**
     * ベクトルとドキュメントを追加
     * @param vector ベクトル
     * @param document ドキュメント
     * @returns エントリーID
     */
    add(vector: number[], document: Document): Promise<string>;
    /**
     * ベクトル検索
     * @param query クエリベクトル
     * @param k 返す結果数
     * @returns 検索結果
     */
    search(query: number[], k?: number): Promise<GitSearchResult[]>;
    /**
     * エントリーをファイルシステムに保存
     */
    private saveEntry;
    /**
     * インデックスファイルを保存
     */
    private saveIndexFile;
    /**
     * 変更をGitにコミット
     */
    private commitChanges;
    /**
     * リモートにプッシュ
     */
    push(): Promise<void>;
    /**
     * リモートからプル
     */
    pull(): Promise<void>;
    /**
     * インデックスサイズを取得
     */
    size(): number;
    /**
     * エントリーをIDで取得
     */
    getEntry(id: string): GitVectorStoreEntry | undefined;
    /**
     * エントリーをIDで削除
     */
    remove(id: string): Promise<boolean>;
    /**
     * インデックスを再構築
     */
    private rebuildIndex;
    /**
     * すべてのエントリーをクリア
     */
    clear(): Promise<void>;
    /**
     * ブランチを切り替え
     * @param branchName ブランチ名
     * @param createIfNotExists 存在しない場合は作成
     */
    switchBranch(branchName: string, createIfNotExists?: boolean): Promise<void>;
    /**
     * 現在のブランチを取得
     */
    getCurrentBranch(): string;
    /**
     * ブランチ一覧を取得
     */
    listBranches(): Promise<string[]>;
    /**
     * コミット履歴を取得
     */
    getCommitHistory(depth?: number): Promise<any[]>;
    /**
     * リソースのクリーンアップ
     */
    cleanup(): Promise<void>;
}

/**
 * @file lib/git/git-embedding-sdk.ts
 * @description Git対応のEmbeddingSDK
 * @author GFTD Co., Ltd.
 */

/**
 * Git対応Embedding設定インターフェース
 */
interface GitEmbeddingConfig {
    /** Git設定 */
    git: GitConfig;
    /** モデル名 (デフォルト: 'Xenova/all-MiniLM-L6-v2') */
    modelName?: string;
    /** ベクトル次元数 */
    dimensions?: number;
}
/**
 * Git対応EmbeddingSDKクラス
 * HuggingFaceTransformersEmbeddingsとGitを使用してテキストをベクトル化し、
 * Gitリポジトリで管理
 */
declare class GitEmbeddingSDK {
    private embeddings;
    private gitFs;
    private vectorStore;
    private config;
    private isInitialized;
    constructor(config: GitEmbeddingConfig);
    /**
     * SDKの初期化
     */
    initialize(): Promise<void>;
    /**
     * テキストをembeddingに変換
     * @param text テキスト
     * @returns embedding vector
     */
    embedText(text: string): Promise<number[]>;
    /**
     * 複数のテキストをembeddingに変換
     * @param texts テキスト配列
     * @returns embedding vectors
     */
    embedTexts(texts: string[]): Promise<number[][]>;
    /**
     * ドキュメントをembeddingに変換してVectorStoreに追加
     * @param documents ドキュメント配列
     * @returns 追加されたドキュメントのID配列
     */
    addDocuments(documents: Document[]): Promise<string[]>;
    /**
     * 類似検索
     * @param query 検索クエリ
     * @param k 返す結果数
     * @returns 類似ドキュメント配列
     */
    search(query: string, k?: number): Promise<{
        document: Document;
        score: number;
        id: string;
        commitSha?: string;
    }[]>;
    /**
     * 新しいセッション（ブランチ）を作成
     * @param sessionName セッション名
     * @param baseBranch 基点となるブランチ（デフォルト: 現在のブランチ）
     */
    createSession(sessionName: string, baseBranch?: string): Promise<void>;
    /**
     * セッション（ブランチ）を切り替え
     * @param sessionName セッション名
     */
    switchSession(sessionName: string): Promise<void>;
    /**
     * 現在のセッション（ブランチ）を取得
     */
    getCurrentSession(): string;
    /**
     * セッション（ブランチ）一覧を取得
     */
    listSessions(): Promise<string[]>;
    /**
     * リモートにプッシュ
     */
    push(): Promise<void>;
    /**
     * リモートからプル
     */
    pull(): Promise<void>;
    /**
     * ファイルをGitリポジトリに保存
     * @param filePath ファイルパス
     * @param content ファイル内容
     * @param commitMessage コミットメッセージ
     */
    saveFile(filePath: string, content: string, commitMessage?: string): Promise<string>;
    /**
     * ファイルをGitリポジトリから読み込み
     * @param filePath ファイルパス
     * @returns ファイル内容
     */
    loadFile(filePath: string): Promise<string>;
    /**
     * ファイルが存在するかチェック
     * @param filePath ファイルパス
     */
    fileExists(filePath: string): Promise<boolean>;
    /**
     * ディレクトリの内容を一覧取得
     * @param dirPath ディレクトリパス
     */
    listFiles(dirPath?: string): Promise<string[]>;
    /**
     * インデックスサイズを取得
     */
    getIndexSize(): Promise<number>;
    /**
     * コミット履歴を取得
     * @param depth 取得する履歴の深さ
     */
    getCommitHistory(depth?: number): Promise<any[]>;
    /**
     * Gitリポジトリの状態を取得
     */
    getStatus(): Promise<any[]>;
    /**
     * 構造化データをJSONとして保存
     * @param filePath ファイルパス
     * @param data データオブジェクト
     * @param commitMessage コミットメッセージ
     */
    saveJSON(filePath: string, data: any, commitMessage?: string): Promise<string>;
    /**
     * JSONファイルを読み込み
     * @param filePath ファイルパス
     * @returns パースされたデータ
     */
    loadJSON(filePath: string): Promise<any>;
    /**
     * セッション設定を保存
     * @param config セッション設定
     */
    saveSessionConfig(config: any): Promise<string>;
    /**
     * セッション設定を読み込み
     * @param sessionName セッション名（省略時は現在のセッション）
     */
    loadSessionConfig(sessionName?: string): Promise<any>;
    /**
     * ベクトルストアを直接取得（高度な操作用）
     */
    getVectorStore(): GitVectorStore;
    /**
     * GitFileSystemを直接取得（高度な操作用）
     */
    getGitFileSystem(): GitFileSystem;
    /**
     * リソースのクリーンアップ
     */
    cleanup(): Promise<void>;
}

/**
 * @file lib/git/actor-git-manager.ts
 * @description Actor/Session管理のGitマネージャー
 * @author GFTD Co., Ltd.
 */

/**
 * Actor情報インターフェース
 * GitLabプロジェクトとしてのActor表現
 */
interface ActorInfo {
    /** GitLab Project ID (数値) - 内部的にはproject_idだが、actor_id概念ではrepository_name(UUID)を使用 */
    id: number;
    /** Repository name with UUID (actor_id概念での実際の識別子) */
    name: string;
    description?: string;
    clone_url: string;
    web_url: string;
    default_branch: string;
    created_at: string;
    updated_at?: string;
}
/**
 * Session情報インターフェース
 */
interface SessionInfo {
    name: string;
    commit: {
        id: string;
        message: string;
        author_name: string;
        author_email: string;
        created_at: string;
    };
    protected: boolean;
    can_push: boolean;
    web_url?: string;
}
/**
 * ActorGitManager設定インターフェース
 */
interface ActorGitManagerConfig {
    /** GitLab設定 */
    gitlab: GitLabConfig;
    /** Embedding設定（モデル名など） */
    embedding?: {
        modelName?: string;
        dimensions?: number;
    };
    /** 作成者情報 */
    author: {
        name: string;
        email: string;
    };
}
/**
 * ActorGitManagerクラス
 * GitLabとGitEmbeddingSDKを統合したActor/Session管理システム
 */
declare class ActorGitManager {
    private gitlabClient;
    private config;
    private embeddingSDKs;
    constructor(config: ActorGitManagerConfig);
    /**
     * 新しいActor（プロジェクト）を作成
     * @param actorConfig Actor作成設定
     * @returns Actor情報
     */
    createActor(actorConfig: CreateProjectConfig): Promise<ActorInfo>;
    /**
     * Actorを取得
     * @param actorId Actor ID
     * @returns Actor情報
     */
    getActor(actorId: number): Promise<ActorInfo>;
    /**
     * 新しいSession（ブランチ）を作成
     * @param actorId Actor ID
     * @param sessionConfig Session作成設定
     * @returns Session情報
     */
    createSession(actorId: number, sessionConfig: CreateBranchConfig): Promise<SessionInfo>;
    /**
     * Sessionを取得
     * @param actorId Actor ID
     * @param sessionName Session名
     * @returns Session情報
     */
    getSession(actorId: number, sessionName: string): Promise<SessionInfo>;
    /**
     * Actorの全Sessionを取得
     * @param actorId Actor ID
     * @returns Session一覧
     */
    listSessions(actorId: number): Promise<SessionInfo[]>;
    /**
     * EmbeddingSDKを初期化
     * @param actorId Actor ID
     * @param branch ブランチ名（省略時はdefault_branch）
     * @returns GitEmbeddingSDK
     */
    initializeEmbeddingSDK(actorId: number, branch?: string): Promise<GitEmbeddingSDK>;
    /**
     * ActorのEmbeddingSDKを取得（未初期化の場合は初期化）
     * @param actorId Actor ID
     * @param branch ブランチ名
     * @returns GitEmbeddingSDK
     */
    getEmbeddingSDK(actorId: number, branch?: string): Promise<GitEmbeddingSDK>;
    /**
     * Actorにドキュメントを追加
     * @param actorId Actor ID
     * @param documents ドキュメント配列
     * @param sessionName セッション名（省略時は現在のセッション）
     * @returns 追加されたドキュメントのID配列
     */
    addDocumentsToActor(actorId: number, documents: Document[], sessionName?: string): Promise<string[]>;
    /**
     * Actorで検索
     * @param actorId Actor ID
     * @param query 検索クエリ
     * @param k 返す結果数
     * @param sessionName セッション名（省略時は現在のセッション）
     * @returns 検索結果
     */
    searchInActor(actorId: number, query: string, k?: number, sessionName?: string): Promise<any[]>;
    /**
     * ActorでSessionを作成し、EmbeddingSDKを初期化
     * @param actorId Actor ID
     * @param sessionName セッション名
     * @param baseBranch 基点となるブランチ（省略時はdefault_branch）
     * @returns GitEmbeddingSDK
     */
    createActorSession(actorId: number, sessionName: string, baseBranch?: string): Promise<GitEmbeddingSDK>;
    /**
     * ActorのSessionを切り替え
     * @param actorId Actor ID
     * @param sessionName セッション名
     * @returns GitEmbeddingSDK
     */
    switchActorSession(actorId: number, sessionName: string): Promise<GitEmbeddingSDK>;
    /**
     * Actorのファイルを保存
     * @param actorId Actor ID
     * @param filePath ファイルパス
     * @param content ファイル内容
     * @param commitMessage コミットメッセージ
     * @param sessionName セッション名
     */
    saveFileToActor(actorId: number, filePath: string, content: string, commitMessage?: string, sessionName?: string): Promise<string>;
    /**
     * Actorからファイルを読み込み
     * @param actorId Actor ID
     * @param filePath ファイルパス
     * @param sessionName セッション名
     */
    loadFileFromActor(actorId: number, filePath: string, sessionName?: string): Promise<string>;
    /**
     * Actorの状態を取得
     * @param actorId Actor ID
     * @param sessionName セッション名
     */
    getActorStatus(actorId: number, sessionName?: string): Promise<{
        actor: ActorInfo;
        currentSession: string;
        sessions: SessionInfo[];
        indexSize: number;
        status: any[];
        commitHistory: any[];
    }>;
    /**
     * Actorを削除
     * @param actorId Actor ID
     */
    deleteActor(actorId: number): Promise<boolean>;
    /**
     * Sessionを削除
     * @param actorId Actor ID
     * @param sessionName セッション名
     */
    deleteSession(actorId: number, sessionName: string): Promise<boolean>;
    /**
     * 全てのEmbeddingSDKをクリーンアップ
     */
    cleanup(): Promise<void>;
}

/**
 * @file lib/git/actor-repository-manager.ts
 * @description アクターリポジトリの作成・初期化マネージャー
 * @author GFTD Co., Ltd.
 */

interface ActorRepositoryConfig {
    name: string;
    description?: string;
    type: string;
    repositoryType: 'local' | 'online';
    repositoryUrl?: string;
    gitConfig: ChatGitConfig;
    localPath?: string;
    repositoryName?: string;
}
interface RepositoryInitResult {
    success: boolean;
    repositoryPath: string;
    gitConfig: ChatGitConfig;
    initialCommitSha?: string;
    error?: string;
}
/**
 * アクターリポジトリ管理クラス
 * ローカル・オンラインリポジトリの作成と初期化を管理
 */
declare class ActorRepositoryManager {
    /**
     * 新しいアクターリポジトリを作成・初期化
     */
    static createActorRepository(config: ActorRepositoryConfig): Promise<RepositoryInitResult>;
    /**
     * ローカルリポジトリを作成
     */
    private static createLocalRepository;
    /**
     * オンラインリポジトリを初期化
     */
    private static initializeOnlineRepository;
    /**
     * 初期ファイルを作成
     */
    private static createInitialFiles;
    /**
     * README.mdの内容を生成
     */
    private static generateReadmeContent;
    /**
     * .gitignoreの内容を生成
     */
    private static generateGitignoreContent;
    /**
     * Actor設定ファイルを生成
     */
    private static generateActorConfig;
    /**
     * package.jsonを生成
     */
    private static generatePackageJson;
    /**
     * package.jsonを作成すべきかチェック
     *