@crewx/cli 0.8.0-rc.66 → 0.8.0-rc.82

package/bin/crewx

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/main.js');

package/dist/bootstrap/crewx-cli.d.ts

@@ -0,0 +1,11 @@
+import { Crewx } from '@crewx/sdk';
+/**
+ * Build a Crewx instance with CLI-standard plugins (FileLogger + SqliteTracing)
+ * and built-in tools registered. Use this from any CLI command that needs a
+ * Crewx instance — keeps environment consistent across query / execute / slack / agent.
+ *
+ * workspaceRoot (= dirname(configPath)) is passed to FileLoggerPlugin so that
+ * per-workspace logs land in {workspaceRoot}/.crewx/logs/. Critical for file://
+ * remote agent delegation (target Crewx must write logs into target workspace).
+ */
+export declare function createCliCrewx(configPath?: string): Promise<Crewx>;

package/dist/bootstrap/crewx-cli.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCliCrewx = createCliCrewx;
+const path_1 = require("path");
+const sdk_1 = require("@crewx/sdk");
+const plugins_1 = require("@crewx/sdk/plugins");
+const register_builtin_tools_1 = require("../register-builtin-tools");
+const version_1 = require("../utils/version");
+/**
+ * Build a Crewx instance with CLI-standard plugins (FileLogger + SqliteTracing)
+ * and built-in tools registered. Use this from any CLI command that needs a
+ * Crewx instance — keeps environment consistent across query / execute / slack / agent.
+ *
+ * workspaceRoot (= dirname(configPath)) is passed to FileLoggerPlugin so that
+ * per-workspace logs land in {workspaceRoot}/.crewx/logs/. Critical for file://
+ * remote agent delegation (target Crewx must write logs into target workspace).
+ */
+async function createCliCrewx(configPath = process.env.CREWX_CONFIG ?? 'crewx.yaml') {
+    const absConfigPath = (0, path_1.resolve)(configPath);
+    const workspaceRoot = (0, path_1.dirname)(absConfigPath);
+    // Pass ourselves back to the SDK: when this Crewx encounters a file:// remote
+    // agent, the SDK uses this factory to bootstrap the target Crewx instance
+    // with the same plugin set (FileLogger + SqliteTracing + built-in tools).
+    const crewx = await sdk_1.Crewx.loadYaml(absConfigPath, {
+        remoteFactory: createCliCrewx,
+    });
+    (0, register_builtin_tools_1.registerBuiltinToolsIfNeeded)(crewx);
+    await crewx.use(new plugins_1.FileLoggerPlugin({ version: version_1.CLI_VERSION, workspaceRoot }));
+    await crewx.use(new plugins_1.SqliteTracingPlugin({ version: version_1.CLI_VERSION }));
+    return crewx;
+}

package/dist/builtin.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Built-in tool router.
+ *
+ * Routes built-in commands (memory, search, doc, etc.) to their respective
+ * @crewx/* package CLI entry points.
+ *
+ * Copied and adapted from packages/cli-bak/src/cli/builtin.handler.ts.
+ */
+export declare const BUILTIN_COMMANDS: Set<string>;
+/**
+ * Wrap main() with tracer.run() if tracer is available.
+ * Falls back to direct main() call on any tracer failure.
+ */
+export declare function wrapWithTracer(builtinName: string, main: (args?: string[]) => Promise<void>, args: string[]): Promise<void>;
+export declare function handleBuiltin(builtinName: string, args: string[]): Promise<void>;

package/dist/{cli/builtin.handler.js → builtin.js}

@@ -1,4 +1,12 @@
 "use strict";
+/**
+ * Built-in tool router.
+ *
+ * Routes built-in commands (memory, search, doc, etc.) to their respective
+ * @crewx/* package CLI entry points.
+ *
+ * Copied and adapted from packages/cli-bak/src/cli/builtin.handler.ts.
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -43,8 +51,10 @@ const BUILTIN_MAP = {
     wbs: () => Promise.resolve().then(() => __importStar(require('@crewx/wbs/cli'))),
     cron: () => Promise.resolve().then(() => __importStar(require('@crewx/cron/cli'))),
     workflow: () => Promise.resolve().then(() => __importStar(require('@crewx/workflow/cli'))),
+    // NOTE: @crewx/skill does not expose /cli module — handled separately in main.ts
 };
 exports.BUILTIN_COMMANDS = new Set(Object.keys(BUILTIN_MAP));
+// Load skill-tracer for observability (graceful degradation if unavailable)
 async function loadTracer() {
     try {
         return await Promise.resolve().then(() => __importStar(require('@crewx/shared/skill-tracer')));
@@ -53,12 +63,17 @@ async function loadTracer() {
         return null;
     }
 }
+/**
+ * Wrap main() with tracer.run() if tracer is available.
+ * Falls back to direct main() call on any tracer failure.
+ */
 async function wrapWithTracer(builtinName, main, args) {
     let tracer = null;
     try {
         tracer = await loadTracer();
     }
     catch {
+        // tracer unavailable — proceed without it
     }
     if (tracer) {
         let mainError = null;
@@ -76,13 +91,12 @@ async function wrapWithTracer(builtinName, main, args) {
             });
             return;
         }
-        catch (err) {
-            if (mainError) {
+        catch {
+            if (mainError)
                 throw mainError;
-            }
-            if (mainCompleted) {
+            if (mainCompleted)
                 return;
-            }
+            // tracer setup error — fall back
         }
     }
     await main(args);
@@ -98,7 +112,8 @@ async function handleBuiltin(builtinName, args) {
         await wrapWithTracer(builtinName, mod.main.bind(mod), args);
     }
     catch (err) {
-        if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ERR_MODULE_NOT_FOUND') {
+        const code = err.code;
+        if (code === 'MODULE_NOT_FOUND' || code === 'ERR_MODULE_NOT_FOUND') {
             console.error(`\n  Built-in tool '${builtinName}' is not installed.\n`);
             console.error(`  Install it with:\n`);
             console.error(`    npm install @crewx/${builtinName}\n`);
@@ -107,4 +122,3 @@ async function handleBuiltin(builtinName, args) {
         throw err;
     }
 }
-//# sourceMappingURL=builtin.handler.js.map

package/dist/commands/agent.d.ts

@@ -0,0 +1,12 @@
+/**
+ * crewx agent handler.
+ * Dispatches `crewx agent ls` and `crewx agent prompt` subcommands.
+ */
+/**
+ * Handle `crewx agent [subcommand] [options]`.
+ *
+ * Subcommands:
+ *   ls | list | (none) — list agents (default)
+ *   prompt <agentId>   — print rendered system prompt
+ */
+export declare function handleAgent(args: string[]): Promise<void>;

package/dist/commands/agent.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * crewx agent handler.
+ * Dispatches `crewx agent ls` and `crewx agent prompt` subcommands.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAgent = handleAgent;
+const path = __importStar(require("path"));
+const fs_1 = require("fs");
+const crewx_cli_1 = require("../bootstrap/crewx-cli");
+const sdk_1 = require("@crewx/sdk");
+const skill_1 = require("@crewx/skill");
+/**
+ * Parse a flag from args array.
+ * Supports both `--flag=value` and `--flag value` forms.
+ * Returns undefined if flag is not present.
+ */
+function parseFlag(args, flag) {
+    const prefix = `--${flag}=`;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i].startsWith(prefix)) {
+            return args[i].slice(prefix.length);
+        }
+        if (args[i] === `--${flag}` && i + 1 < args.length) {
+            return args[i + 1];
+        }
+    }
+    return undefined;
+}
+/**
+ * Format provider field for display.
+ */
+function formatProvider(provider) {
+    return Array.isArray(provider) ? provider.join(', ') : provider;
+}
+/**
+ * Print the agent list.
+ */
+function printAgentList(agents, total, isFiltered) {
+    const configPath = process.env.CREWX_CONFIG ?? null;
+    if (agents.length === 0) {
+        console.log('WARNING: No agents configured.');
+        if (!configPath) {
+            console.log('Set CREWX_CONFIG to point to your crewx.yaml configuration file.');
+        }
+        return;
+    }
+    const headerCount = isFiltered ? `${agents.length} / ${total}` : `${total}`;
+    console.log(`Available Agents (${headerCount})\n`);
+    agents.forEach((agent, index) => {
+        const headerParts = [`@${agent.id}`];
+        if (agent.name && agent.name !== agent.id) {
+            headerParts.push(agent.name);
+        }
+        console.log(`${index + 1}. ${headerParts.join(' - ')}`);
+        console.log(`   Provider: ${formatProvider(agent.provider)}`);
+        const workDir = agent.working_directory ?? agent.workingDirectory ?? '.';
+        console.log(`   Working Dir: ${workDir}`);
+        if (agent.role) {
+            console.log(`   Role: ${agent.role}`);
+        }
+        if (agent.team) {
+            console.log(`   Team: ${agent.team}`);
+        }
+        if (agent.description) {
+            console.log(`   Description: ${agent.description}`);
+        }
+        if (index < agents.length - 1) {
+            console.log('');
+        }
+    });
+    const configSource = configPath ? 'External YAML file' : 'Default hardcoded values';
+    console.log(`\nConfiguration Source: ${configSource}`);
+    if (configPath) {
+        console.log(`Config Path: ${configPath}`);
+    }
+    else {
+        console.log('Tip: Set CREWX_CONFIG to point to your crewx.yaml file to customize agents.');
+    }
+}
+/**
+ * Handle `crewx agent ls` — list agents with optional filters.
+ */
+async function handleAgentList(crewx, args) {
+    const role = parseFlag(args, 'role');
+    const team = parseFlag(args, 'team');
+    const provider = parseFlag(args, 'provider');
+    const isFiltered = !!(role || team || provider);
+    const total = crewx.agents.size;
+    const filtered = crewx.filterAgents({ role, team, provider });
+    printAgentList(filtered, total, isFiltered);
+}
+/**
+ * Handle `crewx agent prompt <agentId>` — print fully rendered system prompt.
+ * Renders Handlebars template variables via Crewx.renderAgentPromptFull().
+ */
+async function handleAgentPrompt(crewx, args) {
+    // Find the agent id argument (first non-flag arg after 'prompt')
+    const agentIdRaw = args.find(a => !a.startsWith('--'));
+    if (!agentIdRaw) {
+        console.error('Missing agent ID. Usage: crewx agent prompt @agent_name');
+        process.exit(1);
+    }
+    try {
+        const skills = loadAgentSkills();
+        const rendered = await crewx.renderAgentPromptFull(agentIdRaw, {
+            env: process.env,
+            session: { mode: 'query', platform: 'cli' },
+            skills,
+        });
+        const displayId = agentIdRaw.startsWith('@') ? agentIdRaw.slice(1) : agentIdRaw;
+        console.log(`\n🤖 **Rendered Prompt for Agent: ${displayId}**\n`);
+        console.log('--- BEGIN PROMPT ---');
+        console.log(rendered);
+        console.log('--- END PROMPT ---');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Failed to get agent prompt: ${message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Handle `crewx agent [subcommand] [options]`.
+ *
+ * Subcommands:
+ *   ls | list | (none) — list agents (default)
+ *   prompt <agentId>   — print rendered system prompt
+ */
+async function handleAgent(args) {
+    const configPath = process.env.CREWX_CONFIG ?? 'crewx.yaml';
+    let crewx;
+    try {
+        crewx = await (0, crewx_cli_1.createCliCrewx)(configPath);
+    }
+    catch (err) {
+        if (err instanceof sdk_1.ConfigLoadError && !(0, fs_1.existsSync)(configPath)) {
+            const subcommand = (args[0] ?? '').toLowerCase();
+            if (!subcommand || subcommand === 'ls' || subcommand === 'list') {
+                console.log('WARNING: No agents configured.');
+                console.log(`No crewx.yaml found. Run 'crewx init' to create one.`);
+                return;
+            }
+        }
+        throw err;
+    }
+    const subcommand = (args[0] ?? '').toLowerCase();
+    switch (subcommand) {
+        case 'ls':
+        case 'list':
+            await handleAgentList(crewx, args.slice(1));
+            return;
+        case '':
+            // Default: no subcommand → ls
+            await handleAgentList(crewx, args.slice(1));
+            return;
+        case 'prompt':
+        case 'p':
+            await handleAgentPrompt(crewx, args.slice(1));
+            return;
+        default:
+            console.error(`Unknown agent subcommand: ${subcommand}`);
+            printAgentHelp();
+            process.exit(1);
+    }
+}
+/**
+ * Discover available skills and convert to SkillEntry format for template rendering.
+ * Searches skills/ and node_modules/@crewx directories.
+ */
+function loadAgentSkills() {
+    try {
+        const engine = new skill_1.SkillEngine(process.cwd());
+        const discovered = engine.discover();
+        return discovered.map(s => ({
+            metadata: {
+                name: s.name,
+                version: s.version ?? '0.0.0',
+                description: s.description ?? '',
+            },
+            filePath: s.skillMdPath ?? path.join(s.dir, 'SKILL.md'),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function printAgentHelp() {
+    console.log(`
+CrewX Agent Management
+
+Usage:
+  crewx agent             # List configured agents (default)
+  crewx agent ls          # List configured agents
+  crewx agent list        # Alias for ls
+  crewx agent prompt <id> # Inspect rendered agent prompt
+
+Filter Options (for agent ls):
+  --role <value>      Filter by agent role (comma-separated for multiple: PM,Dev)
+  --team <value>      Filter by agent team (comma-separated for multiple)
+  --provider <value>  Filter by provider (comma-separated, partial match: claude)
+
+Examples:
+  crewx agent
+  crewx agent ls
+  crewx agent ls --role=PM
+  crewx agent ls --team="CrewX Core 개발팀"
+  crewx agent ls --provider=claude
+  crewx agent ls --role=PM --provider=claude
+  crewx agent ls --role=PM,general
+  CREWX_CONFIG=./crewx.yaml crewx agent list
+`.trim());
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * crewx doctor handler.
+ * Performs system diagnosis: checks config, CLI tools, and environment.
+ *
+ * Usage:
+ *   crewx doctor                  Run full diagnosis
+ *   crewx doctor --config <path>  Use specific config file
+ */
+/**
+ * Handle `crewx doctor` command.
+ */
+export declare function handleDoctor(args: string[]): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * crewx doctor handler.
+ * Performs system diagnosis: checks config, CLI tools, and environment.
+ *
+ * Usage:
+ *   crewx doctor                  Run full diagnosis
+ *   crewx doctor --config <path>  Use specific config file
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDoctor = handleDoctor;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const sdk_1 = require("@crewx/sdk");
+const parse_common_flags_1 = require("./parse-common-flags");
+function statusIcon(status) {
+    switch (status) {
+        case 'success': return '✅';
+        case 'warning': return '⚠️ ';
+        case 'error': return '❌';
+    }
+}
+/**
+ * Check if a CLI command is available on PATH.
+ */
+function isCommandAvailable(cmd) {
+    try {
+        (0, child_process_1.execSync)(`which ${cmd}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check crewx.yaml configuration file.
+ */
+function checkConfig(configPath) {
+    if (!(0, fs_1.existsSync)(configPath)) {
+        return {
+            name: 'Configuration File',
+            status: 'error',
+            message: `Configuration file not found: ${configPath}`,
+            details: "Run 'crewx init' to create a default configuration file.",
+        };
+    }
+    try {
+        const raw = (0, sdk_1.loadYamlFile)(configPath);
+        const config = raw;
+        if (!config?.agents || !Array.isArray(config.agents)) {
+            return {
+                name: 'Configuration File',
+                status: 'error',
+                message: 'Invalid configuration format',
+                details: 'Configuration file exists but has invalid structure.',
+            };
+        }
+        if (config.agents.length === 0) {
+            return {
+                name: 'Configuration File',
+                status: 'warning',
+                message: 'No agents configured',
+                details: 'Add agent definitions to your crewx.yaml.',
+            };
+        }
+        return {
+            name: 'Configuration File',
+            status: 'success',
+            message: `Found ${config.agents.length} agent(s) in ${configPath}`,
+        };
+    }
+    catch (err) {
+        return {
+            name: 'Configuration File',
+            status: 'error',
+            message: 'Failed to parse configuration',
+            details: `Error: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+/**
+ * Check .crewx/logs directory.
+ */
+function checkLogsDir() {
+    const logsDir = (0, path_1.join)(process.cwd(), '.crewx', 'logs');
+    if (!(0, fs_1.existsSync)(logsDir)) {
+        return {
+            name: 'Logs Directory',
+            status: 'warning',
+            message: 'Logs directory not found',
+            details: `Will be created automatically at ${logsDir}`,
+        };
+    }
+    return {
+        name: 'Logs Directory',
+        status: 'success',
+        message: `Logs directory exists: ${logsDir}`,
+    };
+}
+/**
+ * Check CLI provider availability.
+ */
+function checkCliProviders() {
+    const providers = [
+        { name: 'claude', cmd: 'claude', install: 'npm install -g @anthropic-ai/claude-code' },
+        { name: 'gemini', cmd: 'gemini', install: 'npm install -g @google/gemini-cli' },
+        { name: 'copilot (gh)', cmd: 'gh', install: 'brew install gh  # or visit cli.github.com' },
+    ];
+    return providers.map(p => {
+        const available = isCommandAvailable(p.cmd);
+        return {
+            name: `${p.name.toUpperCase()} CLI`,
+            status: available ? 'success' : 'warning',
+            message: available ? 'Installed and available' : 'Not installed or not on PATH',
+            details: available ? undefined : `Install: ${p.install}`,
+        };
+    });
+}
+/**
+ * Check CREWX_CLI env var.
+ */
+function checkEnvVars() {
+    const crewxCli = process.env.CREWX_CLI;
+    if (crewxCli) {
+        return {
+            name: 'CREWX_CLI',
+            status: 'success',
+            message: `Set to: ${crewxCli}`,
+        };
+    }
+    return {
+        name: 'CREWX_CLI',
+        status: 'warning',
+        message: 'Not set — defaulting to "npx crewx"',
+        details: 'This is auto-set at CLI startup; no action needed.',
+    };
+}
+/**
+ * Assess overall health.
+ */
+function assessHealth(diagnostics) {
+    const errors = diagnostics.filter(d => d.status === 'error').length;
+    const warnings = diagnostics.filter(d => d.status === 'warning').length;
+    const successes = diagnostics.filter(d => d.status === 'success').length;
+    if (errors > 0) {
+        return { status: 'error', message: `System has ${errors} error(s) that need attention` };
+    }
+    if (warnings > 0) {
+        return { status: 'warning', message: `System is functional with ${warnings} warning(s)` };
+    }
+    return { status: 'success', message: `System is healthy — all ${successes} checks passed` };
+}
+/**
+ * Handle `crewx doctor` command.
+ */
+async function handleDoctor(args) {
+    const { config } = (0, parse_common_flags_1.parseCommonFlags)(args);
+    const configPath = config ?? process.env.CREWX_CONFIG ?? (0, path_1.join)(process.cwd(), 'crewx.yaml');
+    console.log('🩺 Starting CrewX system diagnosis...\n');
+    const diagnostics = [
+        checkConfig(configPath),
+        checkLogsDir(),
+        checkEnvVars(),
+        ...checkCliProviders(),
+    ];
+    // Print diagnostics
+    diagnostics.forEach(d => {
+        const icon = statusIcon(d.status);
+        console.log(`${icon} ${d.name}: ${d.message}`);
+        if (d.details) {
+            console.log(`   ${d.details}`);
+        }
+    });
+    const health = assessHealth(diagnostics);
+    const healthIcon = statusIcon(health.status);
+    console.log('');
+    console.log('─'.repeat(60));
+    console.log(`${healthIcon} Overall: ${health.message}`);
+    if (health.status === 'success') {
+        console.log('\nNext steps:');
+        console.log('  crewx query "@claude hello"');
+    }
+    else {
+        console.log('\nAddress the issues above, then run `crewx doctor` again.');
+    }
+    if (health.status === 'error') {
+        process.exit(1);
+    }
+}

package/dist/commands/execute.d.ts

@@ -0,0 +1,21 @@
+/**
+ * crewx execute handler.
+ * Parses args, loads config via Crewx SDK, and executes the task.
+ *
+ * Flags:
+ *   --thread <name>          Conversation thread name
+ *   --provider <cli/xxx>     Provider override
+ *   --metadata <json>        Extra metadata JSON (double-quoted object). Propagated to events/hooks/tracing.
+ *                           e.g. --metadata='{"workflow_id":"wf-1"}'
+ *   --verbose                Debug output mode (default: raw agent response only)
+ *   --config/-c <path>       Config file path override
+ *   --output-format <fmt>    Output format (json|text|stream-json)
+ *   --effort <level>         Model effort (high|medium|low)
+ */
+/**
+ * Handle `crewx execute <agentRef> <message>` command.
+ *
+ * Default output: raw agent response only (stdout).
+ * --verbose: debug info written to stderr, response to stdout.
+ */
+export declare function handleExecute(args: string[]): Promise<void>;