@crewx/cli 0.8.4-rc.0 → 0.8.4-rc.2

package/dist/plugins/examples/verify-echo-hook.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env npx tsx
+"use strict";
+/**
+ * Phase 0 e2e verification — EchoHookPlugin logs Claude Code tool calls.
+ *
+ * Run: npx tsx packages/cli/src/plugins/examples/verify-echo-hook.ts
+ * Prereq: claude CLI installed, crewx.yaml with @claude agent
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = require("@crewx/sdk");
+const echo_hook_1 = require("./echo-hook");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const LOG_PATH = (0, path_1.join)((0, os_1.homedir)(), '.crewx', 'logs', 'echo-hook.log');
+async function main() {
+    if ((0, fs_1.existsSync)(LOG_PATH))
+        (0, fs_1.unlinkSync)(LOG_PATH);
+    const crewx = await sdk_1.Crewx.loadYaml('crewx.yaml');
+    await crewx.use(new echo_hook_1.EchoHookPlugin());
+    console.log('[verify] querying @claude with "ls"...');
+    await crewx.query('@claude', 'Run ls in the current directory. Use the Bash tool.');
+    await crewx.close();
+    if (!(0, fs_1.existsSync)(LOG_PATH)) {
+        console.error('[FAIL] echo-hook.log not created');
+        process.exit(1);
+    }
+    const lines = (0, fs_1.readFileSync)(LOG_PATH, 'utf8').trim().split('\n');
+    const entries = lines.map((l) => JSON.parse(l));
+    const hasBeforeTool = entries.some((e) => e.event === 'beforeTool');
+    const hasTraceId = entries.every((e) => e.traceId?.startsWith('tsk_'));
+    const hasToolName = entries
+        .filter((e) => e.event === 'beforeTool')
+        .every((e) => typeof e.tool?.rawName === 'string' && e.tool.rawName.length > 0);
+    console.log(`[verify] entries: ${entries.length}`);
+    console.log(`[verify] beforeTool: ${hasBeforeTool}`);
+    console.log(`[verify] traceId:    ${hasTraceId}`);
+    console.log(`[verify] toolName:   ${hasToolName}`);
+    if (hasBeforeTool && hasTraceId && hasToolName) {
+        console.log('[PASS] Phase 0 e2e verification passed');
+    }
+    else {
+        console.error('[FAIL] Some checks failed');
+        process.exit(1);
+    }
+}
+main().catch((err) => { console.error(err); process.exit(1); });

package/dist/plugins/sqlite-tracing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Re-export of SqliteTracingPlugin with a CLI-friendly constructor that
+ * accepts a plain dbRoot string (in addition to the SDK's options-object form).
+ */
+import { SqliteTracingPlugin as SdkSqliteTracingPlugin } from '@crewx/sdk/plugins';
+export declare class SqliteTracingPlugin extends SdkSqliteTracingPlugin {
+    constructor(dbRootOrOpts?: string | {
+        dbRoot?: string;
+        version?: string;
+    });
+}

package/dist/plugins/sqlite-tracing.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteTracingPlugin = void 0;
+/**
+ * Re-export of SqliteTracingPlugin with a CLI-friendly constructor that
+ * accepts a plain dbRoot string (in addition to the SDK's options-object form).
+ */
+const plugins_1 = require("@crewx/sdk/plugins");
+class SqliteTracingPlugin extends plugins_1.SqliteTracingPlugin {
+    constructor(dbRootOrOpts) {
+        if (typeof dbRootOrOpts === 'string') {
+            super({ dbRoot: dbRootOrOpts });
+        }
+        else {
+            super(dbRootOrOpts);
+        }
+    }
+}
+exports.SqliteTracingPlugin = SqliteTracingPlugin;

package/dist/repository/workspace.repository.d.ts

@@ -0,0 +1,26 @@
+import BetterSqlite3 from 'better-sqlite3';
+export interface WorkspaceRepositoryOptions {
+    /** Root directory under which `.crewx/crewx.db` lives. Defaults to `os.homedir()`. */
+    dbRoot?: string;
+}
+export declare class WorkspaceRepository {
+    private readonly dbPath;
+    constructor(opts?: WorkspaceRepositoryOptions);
+    /**
+     * Register a CLI workspace in the global CrewX DB.
+     *
+     * This is intentionally CLI-owned, not SDK-owned: workspace registration is
+     * CrewX application metadata, while the SDK only needs pure workspace helpers.
+     * Registration is best-effort so `crewx init` remains usable even if tracing
+     * DB setup fails.
+     */
+    registerWorkspace(workspacePath: string): void;
+    ensureSchema(db: InstanceType<typeof BetterSqlite3>): void;
+    resolveSlug(db: InstanceType<typeof BetterSqlite3>, workspaceId: string, workspacePath: string): string;
+    ensureRow(db: InstanceType<typeof BetterSqlite3>, opts: {
+        id: string;
+        slug: string;
+        name: string;
+        workspacePath: string;
+    }): void;
+}

package/dist/repository/workspace.repository.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceRepository = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const sdk_1 = require("@crewx/sdk");
+class WorkspaceRepository {
+    dbPath;
+    constructor(opts = {}) {
+        this.dbPath = (0, path_1.join)(opts.dbRoot ?? (0, os_1.homedir)(), '.crewx', 'crewx.db');
+    }
+    /**
+     * Register a CLI workspace in the global CrewX DB.
+     *
+     * This is intentionally CLI-owned, not SDK-owned: workspace registration is
+     * CrewX application metadata, while the SDK only needs pure workspace helpers.
+     * Registration is best-effort so `crewx init` remains usable even if tracing
+     * DB setup fails.
+     */
+    registerWorkspace(workspacePath) {
+        const normalizedPath = (0, sdk_1.normalizeWorkspacePath)(workspacePath);
+        try {
+            const dbDir = (0, path_1.dirname)(this.dbPath);
+            if (!(0, fs_1.existsSync)(dbDir)) {
+                (0, fs_1.mkdirSync)(dbDir, { recursive: true });
+            }
+            const db = new better_sqlite3_1.default(this.dbPath);
+            try {
+                this.ensureSchema(db);
+                const id = (0, sdk_1.hashWorkspaceId)(normalizedPath);
+                const name = (0, path_1.basename)(normalizedPath);
+                const slug = this.resolveSlug(db, id, normalizedPath);
+                this.ensureRow(db, { id, slug, name, workspacePath: normalizedPath });
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch {
+            // Non-fatal: workspace registration must never crash `crewx init`.
+        }
+    }
+    ensureSchema(db) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS workspaces (
+        id             TEXT PRIMARY KEY,
+        slug           TEXT NOT NULL UNIQUE,
+        name           TEXT NOT NULL,
+        workspace_path TEXT,
+        is_active      INTEGER NOT NULL DEFAULT 1,
+        created_at     TEXT NOT NULL,
+        updated_at     TEXT NOT NULL
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS threads (
+        id            TEXT PRIMARY KEY,
+        workspace_id  TEXT,
+        platform      TEXT NOT NULL DEFAULT 'cli',
+        title         TEXT,
+        first_message TEXT,
+        last_message  TEXT,
+        message_count INTEGER NOT NULL DEFAULT 0,
+        created_at    TEXT NOT NULL,
+        updated_at    TEXT NOT NULL,
+        metadata      TEXT,
+        FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE SET NULL
+      )
+    `);
+    }
+    resolveSlug(db, workspaceId, workspacePath) {
+        const basenameSlug = (0, path_1.basename)(workspacePath);
+        const parentSlug = `${(0, path_1.basename)((0, path_1.dirname)(workspacePath))}/${basenameSlug}`;
+        const candidates = [basenameSlug, parentSlug];
+        try {
+            const slugExistsForOtherWorkspace = (slug) => !!db
+                .prepare('SELECT id FROM workspaces WHERE slug = ? AND id != ?')
+                .get(slug, workspaceId);
+            for (const slug of candidates) {
+                if (!slugExistsForOtherWorkspace(slug))
+                    return slug;
+            }
+            for (let suffix = 2; suffix < 1000; suffix += 1) {
+                const slug = `${parentSlug}-${suffix}`;
+                if (!slugExistsForOtherWorkspace(slug))
+                    return slug;
+            }
+        }
+        catch {
+            // workspaces table may not yet exist during early migration.
+        }
+        return basenameSlug;
+    }
+    ensureRow(db, opts) {
+        const { id, slug, name, workspacePath } = opts;
+        const now = new Date().toISOString();
+        db.prepare(`
+      INSERT OR IGNORE INTO workspaces (id, slug, name, workspace_path, is_active, created_at, updated_at)
+      VALUES (?, ?, ?, ?, 1, ?, ?)
+    `).run(id, slug, name, workspacePath, now, now);
+        db.prepare(`
+      UPDATE workspaces SET workspace_path = ?, updated_at = ? WHERE id = ? AND workspace_path IS NULL
+    `).run(workspacePath, now, id);
+    }
+}
+exports.WorkspaceRepository = WorkspaceRepository;

package/dist/schema/tasks.d.ts

@@ -0,0 +1,7 @@
+import type BetterSqlite3 from 'better-sqlite3';
+/**
+ * Ensure the `tasks` table exists in the given database.
+ * Safe to call multiple times — CREATE TABLE IF NOT EXISTS is idempotent.
+ * Owns the canonical schema for the CLI-side tasks table.
+ */
+export declare function ensureTasksSchema(db: InstanceType<typeof BetterSqlite3>): void;

package/dist/schema/tasks.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureTasksSchema = ensureTasksSchema;
+/**
+ * Ensure the `tasks` table exists in the given database.
+ * Safe to call multiple times — CREATE TABLE IF NOT EXISTS is idempotent.
+ * Owns the canonical schema for the CLI-side tasks table.
+ */
+function ensureTasksSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id                    TEXT PRIMARY KEY,
+      agent_id              TEXT,
+      user_id               TEXT,
+      prompt                TEXT,
+      mode                  TEXT,
+      status                TEXT NOT NULL,
+      result                TEXT,
+      error                 TEXT,
+      started_at            TEXT NOT NULL,
+      completed_at          TEXT,
+      duration_ms           INTEGER,
+      metadata              TEXT,
+      project_id            TEXT,
+      project_name          TEXT,
+      trace_id              TEXT,
+      parent_task_id        TEXT,
+      caller_agent_id       TEXT,
+      model                 TEXT,
+      platform              TEXT,
+      crewx_version         TEXT,
+      input_tokens          INTEGER DEFAULT 0,
+      output_tokens         INTEGER DEFAULT 0,
+      cost_usd              REAL,
+      pid                   INTEGER,
+      rendered_prompt       TEXT,
+      command               TEXT,
+      coding_agent_command  TEXT,
+      exit_code             INTEGER,
+      logs                  TEXT,
+      thread_id             TEXT,
+      project_ref           TEXT,
+      workspace_id          TEXT,
+      workspace_name        TEXT,
+      cached_input_tokens   INTEGER DEFAULT 0
+    )
+  `);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewx/cli",
-  "version": "0.8.4-rc.0",
+  "version": "0.8.4-rc.2",
   "license": "UNLICENSED",
   "engines": {
     "node": ">=20.19.0"
@@ -24,29 +24,29 @@
     "bin",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "vitest run --config ./vitest.config.ts",
-    "test:watch": "vitest --config ./vitest.config.ts",
-    "lint": "echo 'CLI lint pending' && exit 0"
-  },
   "dependencies": {
-    "@crewx/sdk": "workspace:*",
-    "@crewx/memory": "workspace:*",
-    "@crewx/search": "workspace:*",
-    "@crewx/doc": "workspace:*",
-    "@crewx/wbs": "workspace:*",
-    "@crewx/cron": "workspace:*",
-    "@crewx/workflow": "workspace:*",
-    "@crewx/skill": "workspace:*",
-    "@crewx/shared": "workspace:*",
     "@crewx/adapter-slack": "^0.1.4",
-    "better-sqlite3": "*"
+    "better-sqlite3": "*",
+    "@crewx/sdk": "0.8.3-rc.12",
+    "@crewx/doc": "0.1.8",
+    "@crewx/search": "0.1.9",
+    "@crewx/memory": "0.1.10",
+    "@crewx/wbs": "0.1.9",
+    "@crewx/cron": "0.1.8",
+    "@crewx/shared": "0.0.5",
+    "@crewx/workflow": "0.3.17",
+    "@crewx/skill": "0.1.8"
   },
   "devDependencies": {
     "@types/better-sqlite3": "*",
     "@types/node": "^22.0.0",
     "typescript": "^5.4.0",
     "vitest": "^3.1.1"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run --config ./vitest.config.ts",
+    "test:watch": "vitest --config ./vitest.config.ts",
+    "lint": "echo 'CLI lint pending' && exit 0"
   }
-}
+}

package/dist/ai-provider.service.d.ts

@@ -1,34 +0,0 @@
-import { OnModuleInit } from '@nestjs/common';
-import { AIProvider, AIQueryOptions, AIResponse, type PluginProviderConfig, type RemoteProviderConfig } from '@sowonai/crewx-sdk';
-import { DynamicProviderFactory } from './providers/dynamic-provider.factory';
-import { ConfigService } from './services/config.service';
-import { ToolCallService } from './services/tool-call.service';
-import { TracingService } from './services/tracing.service';
-export declare class AIProviderService implements OnModuleInit {
-    private readonly toolCallService;
-    private readonly dynamicProviderFactory;
-    private readonly configService;
-    private readonly tracingService?;
-    private readonly logger;
-    private readonly providers;
-    private availableProviders;
-    private readonly builtInProviderNames;
-    constructor(toolCallService: ToolCallService, dynamicProviderFactory: DynamicProviderFactory, configService: ConfigService, tracingService?: TracingService | undefined);
-    onModuleInit(): Promise<void>;
-    private createBuiltInProviders;
-    private loadPluginProviders;
-    private loadAPIProviders;
-    reloadPluginProviders(): Promise<void>;
-    private registerProvider;
-    initializeProviders(): Promise<void>;
-    queryAI(prompt: string, providerName?: string, options?: AIQueryOptions): Promise<AIResponse>;
-    executeAI(prompt: string, providerName: string, options?: AIQueryOptions): Promise<AIResponse>;
-    getAvailableProviders(): string[];
-    checkAvailableProviders(): Promise<string[]>;
-    getProvider(name: string): AIProvider | undefined;
-    validateCLIInstallation(): Promise<{
-        [key: string]: boolean;
-    }>;
-    getPluginProviders(): PluginProviderConfig[];
-    getRemoteProviders(): RemoteProviderConfig[];
-}

package/dist/ai-provider.service.js

@@ -1,311 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-var AIProviderService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AIProviderService = void 0;
-const common_1 = require("@nestjs/common");
-const crewx_sdk_1 = require("@sowonai/crewx-sdk");
-const dynamic_provider_factory_1 = require("./providers/dynamic-provider.factory");
-const config_service_1 = require("./services/config.service");
-const tool_call_service_1 = require("./services/tool-call.service");
-const logger_adapter_1 = require("./providers/logger.adapter");
-const version_1 = require("./version");
-const tracing_service_1 = require("./services/tracing.service");
-let AIProviderService = AIProviderService_1 = class AIProviderService {
-    constructor(toolCallService, dynamicProviderFactory, configService, tracingService) {
-        this.toolCallService = toolCallService;
-        this.dynamicProviderFactory = dynamicProviderFactory;
-        this.configService = configService;
-        this.tracingService = tracingService;
-        this.logger = new common_1.Logger(AIProviderService_1.name);
-        this.providers = new Map();
-        this.availableProviders = [];
-        this.builtInProviderNames = new Set([
-            crewx_sdk_1.BuiltInProviders.CLAUDE,
-            crewx_sdk_1.BuiltInProviders.GEMINI,
-            crewx_sdk_1.BuiltInProviders.COPILOT,
-            crewx_sdk_1.BuiltInProviders.CODEX,
-        ]);
-    }
-    async onModuleInit() {
-        for (const provider of this.createBuiltInProviders()) {
-            this.registerProvider(provider);
-        }
-        await this.loadPluginProviders();
-        await this.loadAPIProviders();
-    }
-    createBuiltInProviders() {
-        const taskLogHandler = (0, logger_adapter_1.createTaskLogHandler)(this.tracingService);
-        return [
-            new crewx_sdk_1.ClaudeProvider({
-                logger: (0, logger_adapter_1.createLoggerAdapter)('ClaudeProvider'),
-                toolCallHandler: this.toolCallService,
-                crewxVersion: version_1.CREWX_VERSION,
-                taskLogHandler,
-            }),
-            new crewx_sdk_1.GeminiProvider({
-                logger: (0, logger_adapter_1.createLoggerAdapter)('GeminiProvider'),
-                toolCallHandler: this.toolCallService,
-                crewxVersion: version_1.CREWX_VERSION,
-                taskLogHandler,
-            }),
-            new crewx_sdk_1.CopilotProvider({
-                logger: (0, logger_adapter_1.createLoggerAdapter)('CopilotProvider'),
-                toolCallHandler: this.toolCallService,
-                crewxVersion: version_1.CREWX_VERSION,
-                taskLogHandler,
-            }),
-            new crewx_sdk_1.CodexProvider({
-                logger: (0, logger_adapter_1.createLoggerAdapter)('CodexProvider'),
-                toolCallHandler: this.toolCallService,
-                crewxVersion: version_1.CREWX_VERSION,
-                taskLogHandler,
-            }),
-        ];
-    }
-    async loadPluginProviders() {
-        try {
-            const dynamicConfigs = this.configService.getDynamicProviders();
-            if (!dynamicConfigs || dynamicConfigs.length === 0) {
-                this.logger.log('No dynamic providers defined in config');
-                return;
-            }
-            for (const providerConfig of dynamicConfigs) {
-                try {
-                    if (!this.dynamicProviderFactory.validateConfig(providerConfig)) {
-                        this.logger.warn(`Invalid dynamic provider config: ${providerConfig.id}`);
-                        this.logger.debug(`Config dump: ${JSON.stringify(providerConfig, null, 2)}`);
-                        continue;
-                    }
-                    const provider = this.dynamicProviderFactory.createProvider(providerConfig);
-                    this.registerProvider(provider);
-                    this.logger.log(`✅ Registered ${providerConfig.type} provider: ${providerConfig.id}`);
-                }
-                catch (error) {
-                    this.logger.error(`Failed to load dynamic provider '${providerConfig.id || 'unknown'}': ${error.message}`, error.stack);
-                }
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to load dynamic providers:', error);
-        }
-    }
-    async loadAPIProviders() {
-        try {
-            const apiProviderConfigs = this.configService.getAllAPIProviderConfigs();
-            if (!apiProviderConfigs || apiProviderConfigs.size === 0) {
-                this.logger.log('No API providers defined in config');
-                return;
-            }
-            for (const [agentId, apiConfig] of apiProviderConfigs) {
-                try {
-                    const normalizedConfig = (0, crewx_sdk_1.normalizeAPIProviderConfig)(apiConfig);
-                    const taskLogHandler = (0, logger_adapter_1.createTaskLogHandler)(this.tracingService);
-                    const { MastraAPIProvider } = require('@sowonai/crewx-sdk/api');
-                    const provider = new MastraAPIProvider(normalizedConfig.config);
-                    if (taskLogHandler) {
-                        provider.setTaskLogHandler(taskLogHandler);
-                    }
-                    const agentConfig = this.configService.getAgentConfig(agentId);
-                    const allowedToolNames = new Set();
-                    this.logger.debug(`[Tool Loading] normalizedConfig.permissionsByMode: ${JSON.stringify(normalizedConfig.permissionsByMode, null, 2)}`);
-                    for (const permissions of Object.values(normalizedConfig.permissionsByMode)) {
-                        for (const toolName of permissions.tools) {
-                            allowedToolNames.add(toolName);
-                        }
-                    }
-                    this.logger.debug(`[Tool Loading] allowedToolNames: ${Array.from(allowedToolNames).join(', ')}`);
-                    if (allowedToolNames.size > 0) {
-                        const tools = [];
-                        const { readFileTool, writeFileTool, replaceTool, lsTool, treeTool, grepTool, findTool, globTool, runShellCommandTool, } = require('@sowonai/crewx-sdk/tools');
-                        const builtInTools = {
-                            read_file: readFileTool,
-                            write_file: writeFileTool,
-                            replace: replaceTool,
-                            ls: lsTool,
-                            tree: treeTool,
-                            grep: grepTool,
-                            find: findTool,
-                            glob: globTool,
-                            run_shell_command: runShellCommandTool,
-                        };
-                        for (const toolName of allowedToolNames) {
-                            const tool = builtInTools[toolName];
-                            if (tool) {
-                                tools.push(tool);
-                                this.logger.log(`✅ Loaded tool: ${toolName} for agent ${agentId}`);
-                            }
-                            else {
-                                this.logger.warn(`⚠️  Unknown tool: ${toolName} for agent ${agentId}`);
-                                this.logger.debug(`Available tools: ${Object.keys(builtInTools).join(', ')}`);
-                            }
-                        }
-                        const context = {
-                            agent: {
-                                id: agentId,
-                                provider: apiConfig.provider,
-                                model: apiConfig.model,
-                                temperature: apiConfig.temperature,
-                                maxTokens: apiConfig.maxTokens,
-                            },
-                            env: this.configService.getEnvironmentVariables(),
-                            mode: 'query',
-                            platform: 'cli',
-                        };
-                        provider.setTools(tools, context);
-                        this.logger.log(`✅ Configured ${tools.length} tool(s) for agent ${agentId}`);
-                    }
-                    const wrappedProvider = {
-                        name: agentId,
-                        isAvailable: provider.isAvailable.bind(provider),
-                        query: provider.query.bind(provider),
-                        execute: provider.execute.bind(provider),
-                        getToolPath: provider.getToolPath?.bind(provider),
-                    };
-                    this.registerProvider(wrappedProvider);
-                    this.logger.log(`✅ Registered API provider for agent: ${agentId} (${apiConfig.provider}/${apiConfig.model})`);
-                }
-                catch (error) {
-                    this.logger.error(`Failed to load API provider for agent '${agentId}': ${error.message}`, error.stack);
-                }
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to load API providers:', error);
-        }
-    }
-    async reloadPluginProviders() {
-        for (const [name] of this.providers) {
-            if (!this.builtInProviderNames.has(name)) {
-                this.providers.delete(name);
-            }
-        }
-        await this.loadPluginProviders();
-        await this.loadAPIProviders();
-    }
-    registerProvider(provider) {
-        this.providers.set(provider.name, provider);
-        this.logger.log(`Registered AI provider: ${provider.name}`);
-    }
-    async initializeProviders() {
-        this.logger.log('Initializing AI providers...');
-        this.availableProviders = [];
-        const checks = Array.from(this.providers.entries()).map(async ([name, provider]) => {
-            try {
-                const isAvailable = await provider.isAvailable();
-                if (isAvailable) {
-                    this.availableProviders.push(name);
-                    this.logger.log(`✅ ${name} provider is available`);
-                }
-                else {
-                    this.logger.warn(`❌ ${name} provider is not available`);
-                }
-                return { name, isAvailable };
-            }
-            catch (error) {
-                this.logger.error(`Error checking ${name} provider:`, error);
-                return { name, isAvailable: false };
-            }
-        });
-        await Promise.all(checks);
-        this.logger.log(`Available providers: ${this.availableProviders.join(', ')}`);
-    }
-    async queryAI(prompt, providerName = crewx_sdk_1.BuiltInProviders.CLAUDE, options = {}) {
-        const provider = this.providers.get(providerName);
-        if (!provider) {
-            throw new crewx_sdk_1.ProviderNotAvailableError(providerName);
-        }
-        const isAvailable = await provider.isAvailable();
-        if (!isAvailable) {
-            throw new crewx_sdk_1.ProviderNotAvailableError(providerName);
-        }
-        try {
-            if (typeof provider.queryWithTools === 'function') {
-                this.logger.log(`Using queryWithTools for ${providerName} in query mode`);
-                return await provider.queryWithTools(prompt, options);
-            }
-            return await provider.query(prompt, options);
-        }
-        catch (error) {
-            this.logger.error(`Error querying ${providerName}:`, error);
-            return {
-                content: '',
-                provider: providerName,
-                command: `${providerName} query`,
-                success: false,
-                error: error.message || 'Unknown error occurred',
-            };
-        }
-    }
-    async executeAI(prompt, providerName, options = {}) {
-        const provider = this.providers.get(providerName);
-        if (!provider) {
-            throw new crewx_sdk_1.ProviderNotAvailableError(providerName);
-        }
-        const isAvailable = await provider.isAvailable();
-        if (!isAvailable) {
-            throw new crewx_sdk_1.ProviderNotAvailableError(providerName);
-        }
-        try {
-            if (typeof provider.queryWithTools === 'function') {
-                this.logger.log(`Using queryWithTools for ${providerName} in execute mode`);
-                return await provider.queryWithTools(prompt, options);
-            }
-            return await provider.execute(prompt, options);
-        }
-        catch (error) {
-            this.logger.error(`Error executing ${providerName}:`, error);
-            return {
-                content: '',
-                provider: providerName,
-                command: `${providerName} execute`,
-                success: false,
-                error: error.message || 'Unknown error occurred',
-            };
-        }
-    }
-    getAvailableProviders() {
-        return Array.from(this.providers.keys());
-    }
-    async checkAvailableProviders() {
-        await this.initializeProviders();
-        return this.getAvailableProviders();
-    }
-    getProvider(name) {
-        return this.providers.get(name);
-    }
-    async validateCLIInstallation() {
-        const installation = {};
-        for (const [name, provider] of this.providers) {
-            installation[name] = await provider.isAvailable();
-        }
-        return installation;
-    }
-    getPluginProviders() {
-        return this.configService.getPluginProviders();
-    }
-    getRemoteProviders() {
-        return this.configService.getRemoteProviders();
-    }
-};
-exports.AIProviderService = AIProviderService;
-exports.AIProviderService = AIProviderService = AIProviderService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __param(3, (0, common_1.Optional)()),
-    __metadata("design:paramtypes", [tool_call_service_1.ToolCallService,
-        dynamic_provider_factory_1.DynamicProviderFactory,
-        config_service_1.ConfigService,
-        tracing_service_1.TracingService])
-], AIProviderService);
-//# sourceMappingURL=ai-provider.service.js.map