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

package/dist/commands/hook-dispatch.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * crewx hook-dispatch — CLI subcommand invoked by Claude/Codex PreToolUse hook.
+ *
+ * Reads stdin JSON from the provider, loads HookPlugins from crewx.yaml,
+ * evaluates them, and writes stdout JSON response back.
+ *
+ * Protocol:
+ *   stdin  → ClaudeHookInput JSON
+ *   stdout → ClaudeHookOutput JSON
+ *   exit 0 → allow, exit 2 → deny
+ *
+ * Security (M1):
+ *   --provider argument is REQUIRED. Missing → process.exit(1) fail-closed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHookDispatch = handleHookDispatch;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const sdk_1 = require("@crewx/sdk");
+const hooks_1 = require("@crewx/sdk/hooks");
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => { data += chunk; });
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', reject);
+    });
+}
+function loadPlugin(pluginPath) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require(pluginPath);
+    const PluginClass = mod.default ?? mod;
+    if (typeof PluginClass !== 'function') {
+        throw new Error(`Plugin module does not export a class: ${pluginPath}`);
+    }
+    const instance = new PluginClass();
+    if (typeof instance.run !== 'function') {
+        throw new Error(`Plugin does not have a run() method: ${pluginPath}`);
+    }
+    return instance;
+}
+function findConfigPath(cwd) {
+    let dir = cwd;
+    for (let i = 0; i < 20; i++) {
+        const candidate = (0, path_1.resolve)(dir, 'crewx.yaml');
+        try {
+            (0, fs_1.readFileSync)(candidate, 'utf8');
+            return candidate;
+        }
+        catch {
+            const parent = (0, path_1.resolve)(dir, '..');
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    return null;
+}
+function parseProviderFromArgs(args) {
+    const idx = args.indexOf('--provider');
+    if (idx === -1 || idx + 1 >= args.length) {
+        console.error('[crewx] Missing required --provider argument. Usage: hook-dispatch --provider <claude|codex>');
+        process.exit(1);
+    }
+    const val = args[idx + 1];
+    if (val !== 'claude' && val !== 'codex') {
+        console.error(`[crewx] Invalid --provider value: "${val}". Expected: claude | codex`);
+        process.exit(1);
+    }
+    return val;
+}
+async function handleHookDispatch(args) {
+    const provider = parseProviderFromArgs(args);
+    const stdinData = await readStdin();
+    let input;
+    try {
+        input = JSON.parse(stdinData);
+    }
+    catch {
+        console.error('[crewx] Failed to parse stdin JSON');
+        process.exit(1);
+    }
+    const configPath = findConfigPath(input.cwd || process.cwd());
+    if (!configPath) {
+        const output = {
+            hookSpecificOutput: {
+                hookEventName: input.hook_event_name,
+                permissionDecision: 'allow',
+            },
+        };
+        process.stdout.write(JSON.stringify(output));
+        process.exit(0);
+    }
+    const configRoot = (0, path_1.dirname)(configPath);
+    let config;
+    try {
+        config = (0, sdk_1.loadYamlFile)(configPath);
+    }
+    catch {
+        console.error(`[crewx] Failed to load crewx.yaml: ${configPath}`);
+        process.exit(1);
+    }
+    const hookDefs = Array.isArray(config.hooks) ? config.hooks : [];
+    const matchingDefs = hookDefs.filter((h) => {
+        const prov = h.provider;
+        if (prov === undefined)
+            return true;
+        if (typeof prov === 'string')
+            return prov === provider;
+        if (Array.isArray(prov))
+            return prov.includes(provider);
+        return false;
+    }).filter((h) => h.event === 'PreToolUse' || !h.event);
+    if (matchingDefs.length === 0) {
+        const output = {
+            hookSpecificOutput: {
+                hookEventName: input.hook_event_name,
+                permissionDecision: 'allow',
+            },
+        };
+        process.stdout.write(JSON.stringify(output));
+        process.exit(0);
+    }
+    const guideDefs = matchingDefs.filter((h) => h.guide && typeof h.guide === 'object');
+    const pluginDefs = matchingDefs.filter((h) => h.plugin && typeof h.plugin === 'string');
+    if (guideDefs.length > 0) {
+        const { valid, warnings } = (0, hooks_1.validateHooksSchema)(guideDefs);
+        for (const w of warnings) {
+            process.stderr.write(`[crewx] ${w}\n`);
+        }
+        if (valid.length > 0) {
+            const agents = Array.isArray(config.agents) ? config.agents : [];
+            const yamlPlugin = new hooks_1.YamlHookPlugin({ hooks: valid, agents });
+            const result = await (0, hooks_1.evaluateHook)(yamlPlugin, input, configRoot, provider);
+            if (result.exitCode !== 0) {
+                process.stdout.write(JSON.stringify(result.stdout));
+                process.exit(result.exitCode);
+            }
+            if (result.injected) {
+                process.stdout.write(JSON.stringify(result.stdout));
+                process.exit(0);
+            }
+        }
+    }
+    for (const hookDef of pluginDefs) {
+        const pluginRelPath = hookDef.plugin;
+        if (!pluginRelPath) {
+            console.error(`[crewx] Hook definition missing 'plugin' field`);
+            continue;
+        }
+        const pluginPath = (0, path_1.resolve)(configRoot, pluginRelPath);
+        if (!(0, hooks_1.isPathSafe)(pluginPath, configRoot)) {
+            console.error(`[crewx] Hook plugin path rejected (path traversal): ${pluginRelPath}`);
+            process.exit(1);
+        }
+        let plugin;
+        try {
+            plugin = loadPlugin(pluginPath);
+        }
+        catch (err) {
+            console.error(`[crewx] Failed to load hook plugin: ${pluginRelPath} — ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+        const result = await (0, hooks_1.evaluateHook)(plugin, input, configRoot, provider);
+        if (result.exitCode !== 0) {
+            process.stdout.write(JSON.stringify(result.stdout));
+            process.exit(result.exitCode);
+        }
+    }
+    const output = {
+        hookSpecificOutput: {
+            hookEventName: input.hook_event_name,
+            permissionDecision: 'allow',
+        },
+    };
+    process.stdout.write(JSON.stringify(output));
+    process.exit(0);
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,24 @@
+/**
+ * crewx init handler.
+ * Initializes a CrewX project by creating crewx.yaml and supporting dirs.
+ *
+ * Usage:
+ *   crewx init                     Create crewx.yaml in current directory
+ *   crewx init --force             Overwrite existing configuration
+ */
+export interface InitResult {
+    yamlCreated: boolean;
+    hookInstalled: boolean;
+    errors: string[];
+    skippedReason?: 'yaml-exists' | 'nested-project';
+}
+/**
+ * Programmatic init — creates crewx.yaml, support dirs, and optionally installs hooks.
+ * Throws on unrecoverable errors (PATH_NOT_FOUND, NESTED_CREWX_PROJECT, YAML_CREATE_FAILED).
+ * Partial failures (hook install, mkdir) are collected in InitResult.errors without rollback.
+ */
+export declare function handleInit(opts: {
+    path: string;
+    skipHook?: boolean;
+    force?: boolean;
+}): Promise<InitResult>;

package/dist/commands/init.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * crewx init handler.
+ * Initializes a CrewX project by creating crewx.yaml and supporting dirs.
+ *
+ * Usage:
+ *   crewx init                     Create crewx.yaml in current directory
+ *   crewx init --force             Overwrite existing configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleInit = handleInit;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const install_1 = require("./hook/install");
+const paths_1 = require("./hook/paths");
+const DEFAULT_AGENTS = [
+    {
+        id: 'planner',
+        name: 'Planner',
+        role: 'Product/Architecture Planner',
+        team: 'core',
+        provider: 'cli/claude',
+        default_model: 'claude-opus-4-7',
+        working_directory: './',
+        description: '요구 분석·설계·작업 분해를 담당',
+        system_prompt: `You are a planner. Break down user goals into concrete,\ntestable steps. Challenge assumptions. Never write code directly.`,
+    },
+    {
+        id: 'developer',
+        name: 'Developer',
+        role: 'Implementation Engineer',
+        team: 'core',
+        provider: 'cli/claude',
+        default_model: 'claude-opus-4-7',
+        working_directory: './',
+        description: '실제 코드 작성과 테스트',
+        system_prompt: `Implement what the planner specifies. Prefer editing\nexisting files. Run tests before reporting done.`,
+    },
+    {
+        id: 'reviewer',
+        name: 'Reviewer',
+        role: 'Code Reviewer',
+        team: 'core',
+        provider: 'cli/claude',
+        default_model: 'claude-opus-4-7',
+        working_directory: './',
+        description: '코드 품질·보안·가독성 리뷰',
+        system_prompt: `Review diffs for correctness, security, readability.\nCite file:line. Be blunt, not polite.`,
+    },
+];
+function escapeYamlBlock(text) {
+    return text
+        .split('\n')
+        .map((line) => `      ${line}`)
+        .join('\n');
+}
+function generateDefaultYaml(agents) {
+    const agentBlocks = agents
+        .map((a) => `  - id: "${a.id}"
+    name: "${a.name}"
+    role: "${a.role}"
+    team: "${a.team}"
+    provider: "${a.provider}"
+    default_model: "${a.default_model}"
+    working_directory: "${a.working_directory}"
+    description: "${a.description}"
+    system_prompt: |
+${escapeYamlBlock(a.system_prompt)}`)
+        .join('\n\n');
+    return `# CrewX Agents Configuration
+# Generated by 'crewx init'
+
+agents:
+${agentBlocks}
+
+# Usage examples:
+#   crewx query "@planner analyze this codebase"
+#   crewx execute "@developer implement the feature described above"
+#   crewx agent ls
+`;
+}
+/**
+ * Programmatic init — creates crewx.yaml, support dirs, and optionally installs hooks.
+ * Throws on unrecoverable errors (PATH_NOT_FOUND, NESTED_CREWX_PROJECT, YAML_CREATE_FAILED).
+ * Partial failures (hook install, mkdir) are collected in InitResult.errors without rollback.
+ */
+async function handleInit(opts) {
+    const { path: target, skipHook = false, force = false } = opts;
+    const errors = [];
+    let yamlCreated = false;
+    let hookInstalled = false;
+    if (!(0, fs_1.existsSync)(target)) {
+        throw new Error(`PATH_NOT_FOUND: ${target}`);
+    }
+    // Reject if a parent directory already owns a crewx project
+    const parentRoot = (0, paths_1.findProjectRoot)((0, path_1.dirname)(target));
+    if (parentRoot && parentRoot !== target) {
+        throw new Error(`NESTED_CREWX_PROJECT: parent root at ${parentRoot}`);
+    }
+    const yamlPath = (0, path_1.join)(target, 'crewx.yaml');
+    const ymlPath = (0, path_1.join)(target, 'crewx.yml');
+    if ((0, fs_1.existsSync)(yamlPath) || (0, fs_1.existsSync)(ymlPath)) {
+        if (!force) {
+            return { yamlCreated: false, hookInstalled: false, errors: [], skippedReason: 'yaml-exists' };
+        }
+    }
+    try {
+        const content = generateDefaultYaml(DEFAULT_AGENTS);
+        (0, fs_1.writeFileSync)(yamlPath, content, 'utf-8');
+        yamlCreated = true;
+    }
+    catch (e) {
+        throw new Error(`YAML_CREATE_FAILED: ${e.message}`);
+    }
+    for (const dir of ['.crewx/logs', '.claude/commands']) {
+        try {
+            (0, fs_1.mkdirSync)((0, path_1.join)(target, dir), { recursive: true });
+        }
+        catch (e) {
+            errors.push(`MKDIR_FAILED:${dir}:${e.message}`);
+        }
+    }
+    if (!skipHook) {
+        try {
+            await (0, install_1.handleHookInstall)({ projectRoot: target, yes: true });
+            hookInstalled = true;
+        }
+        catch (e) {
+            errors.push(`HOOK_INSTALL_FAILED: ${e.message}`);
+        }
+    }
+    return { yamlCreated, hookInstalled, errors };
+}

package/dist/commands/kill.d.ts

@@ -0,0 +1,12 @@
+/**
+ * crewx kill handler.
+ * Kills a running task by ID or kills all running tasks.
+ *
+ * Usage:
+ *   crewx kill <task-id>   Kill a specific running task
+ *   crewx kill --all       Kill all running tasks
+ */
+/**
+ * Handle `crewx kill` command.
+ */
+export declare function handleKill(args: string[]): Promise<void>;

package/dist/commands/kill.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * crewx kill handler.
+ * Kills a running task by ID or kills all running tasks.
+ *
+ * Usage:
+ *   crewx kill <task-id>   Kill a specific running task
+ *   crewx kill --all       Kill all running tasks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleKill = handleKill;
+const task_db_1 = require("./task-db");
+/**
+ * Handle `crewx kill` command.
+ */
+async function handleKill(args) {
+    const killAll = args.includes('--all');
+    const taskId = args.find(a => !a.startsWith('--'));
+    if (!taskId && !killAll) {
+        console.error('Error: Please provide a task ID or use --all to kill all running tasks.');
+        console.error('');
+        console.error('Usage:');
+        console.error('  crewx kill <task-id>    Kill a running task by ID');
+        console.error('  crewx kill --all        Kill all running tasks');
+        process.exit(1);
+        return;
+    }
+    if (killAll) {
+        const running = (0, task_db_1.getRunningTasks)();
+        if (running.length === 0) {
+            console.log('No running tasks found.');
+            return;
+        }
+        console.log(`Found ${running.length} running task(s). Killing...`);
+        for (const task of running) {
+            const r = (0, task_db_1.killTask)(task.id);
+            console.log(r.message);
+        }
+        return;
+    }
+    const r = (0, task_db_1.killTask)(taskId);
+    if (r.ok) {
+        console.log(r.message);
+    }
+    else {
+        console.error(`Error: ${r.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/log.d.ts

@@ -0,0 +1,13 @@
+/**
+ * crewx log handler.
+ * Lists task execution logs or shows a specific task log.
+ *
+ * Usage:
+ *   crewx log              List all tasks (newest first)
+ *   crewx log ls           Same as above
+ *   crewx log <task_id>    Show specific task details
+ */
+/**
+ * Handle `crewx log` command.
+ */
+export declare function handleLog(args: string[]): Promise<void>;

package/dist/commands/log.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * crewx log handler.
+ * Lists task execution logs or shows a specific task log.
+ *
+ * Usage:
+ *   crewx log              List all tasks (newest first)
+ *   crewx log ls           Same as above
+ *   crewx log <task_id>    Show specific task details
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleLog = handleLog;
+const task_db_1 = require("./task-db");
+function statusIcon(status) {
+    switch (status) {
+        case 'running': return '⏳';
+        case 'success': return '✅';
+        case 'failed': return '❌';
+    }
+}
+/**
+ * Handle `crewx log` command.
+ */
+async function handleLog(args) {
+    const action = args[0];
+    const isTaskId = action && (action.startsWith('tsk_') || action.startsWith('task_'));
+    const isListCommand = !action || action === 'ls' || action === 'list';
+    if (isTaskId) {
+        // Show specific task
+        const task = (0, task_db_1.getTask)(action);
+        if (!task) {
+            console.error(`Task not found: ${action}`);
+            process.exit(1);
+            return;
+        }
+        console.log(`\nTask Log\n${'='.repeat(60)}`);
+        console.log(`Task ID: ${task.id}`);
+        console.log(`Status: ${statusIcon(task.status)} ${task.status}`);
+        console.log(`Agent: ${task.agent_id}`);
+        console.log(`Mode: ${task.mode}`);
+        console.log(`Started: ${new Date(task.started_at).toLocaleString()}`);
+        if (task.completed_at) {
+            const duration = new Date(task.completed_at).getTime() - new Date(task.started_at).getTime();
+            console.log(`Completed: ${new Date(task.completed_at).toLocaleString()} (${duration}ms)`);
+        }
+        console.log('='.repeat(60));
+        console.log('');
+        if (task.status === 'success' && task.result) {
+            console.log('Result:');
+            console.log(task.result);
+        }
+        else if (task.status === 'failed' && task.error) {
+            console.log(`Error: ${task.error}`);
+        }
+        else if (task.status === 'running') {
+            console.log('(task is still running)');
+        }
+        return;
+    }
+    if (isListCommand) {
+        const allTasks = (0, task_db_1.getAllTasks)();
+        console.log('\nAvailable Task Logs');
+        console.log('='.repeat(60));
+        const total = allTasks.length;
+        const completed = allTasks.filter(t => t.status === 'success').length;
+        const failed = allTasks.filter(t => t.status === 'failed').length;
+        const running = allTasks.filter(t => t.status === 'running').length;
+        console.log(`Total: ${total} | ✅ Completed: ${completed} | ❌ Failed: ${failed} | ⏳ Running: ${running}`);
+        console.log('='.repeat(60));
+        console.log('');
+        if (allTasks.length === 0) {
+            console.log('No task logs found.');
+            console.log('Tip: Run `crewx query` or `crewx execute` to create tasks.');
+            return;
+        }
+        allTasks.forEach((task, idx) => {
+            const icon = statusIcon(task.status);
+            const duration = task.completed_at
+                ? `${new Date(task.completed_at).getTime() - new Date(task.started_at).getTime()}ms`
+                : 'running...';
+            console.log(`${idx + 1}. ${icon} ${task.id}`);
+            console.log(`   Agent: ${task.agent_id}  Mode: ${task.mode}`);
+            console.log(`   Started: ${new Date(task.started_at).toLocaleString()}`);
+            console.log(`   Duration: ${duration}`);
+            console.log('');
+        });
+        console.log('Tip: Use "crewx log <task_id>" to view detailed log');
+        return;
+    }
+    console.error(`Unknown log action: ${action}`);
+    console.error('');
+    console.error('Usage:');
+    console.error('  crewx log              List all logs (default)');
+    console.error('  crewx log ls           List all logs');
+    console.error('  crewx log <task_id>    View specific log');
+    process.exit(1);
+}

package/dist/commands/parse-agent-message.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared utility for parsing agent reference and message from CLI args.
+ *
+ * Supported call forms:
+ *   crewx query '@claude 안녕'       → agentRef='@claude', message='안녕'
+ *   crewx query '@claude' '안녕'     → agentRef='@claude', message='안녕'
+ *   crewx query '@claude' '안녕' '해' → agentRef='@claude', message='안녕 해'
+ *   crewx query '안녕하세요'          → agentRef='',        message='안녕하세요' (default agent)
+ *
+ * Only @mention form triggers explicit agent selection. Input without a
+ * leading @mention uses the default agent (@crewx) — callers are responsible
+ * for applying the fallback.
+ *
+ * Reusable by query, execute, and any future command that accepts an agent ref.
+ */
+export interface AgentMessage {
+    agentRef: string;
+    message: string;
+}
+/**
+ * Parse agent reference and message from CLI args array.
+ *
+ * Joins all args with a single space first, then splits on the first
+ * whitespace boundary so that both the "single-chunk" form
+ * (`'@claude 안녕'`) and the "separated" form (`'@claude', '안녕'`) produce
+ * identical results.
+ *
+ * Returns agentRef='' when no leading @mention is found — the caller should
+ * default to '@crewx' in that case.
+ */
+export declare function parseAgentMessage(args: string[]): AgentMessage;

package/dist/commands/parse-agent-message.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Shared utility for parsing agent reference and message from CLI args.
+ *
+ * Supported call forms:
+ *   crewx query '@claude 안녕'       → agentRef='@claude', message='안녕'
+ *   crewx query '@claude' '안녕'     → agentRef='@claude', message='안녕'
+ *   crewx query '@claude' '안녕' '해' → agentRef='@claude', message='안녕 해'
+ *   crewx query '안녕하세요'          → agentRef='',        message='안녕하세요' (default agent)
+ *
+ * Only @mention form triggers explicit agent selection. Input without a
+ * leading @mention uses the default agent (@crewx) — callers are responsible
+ * for applying the fallback.
+ *
+ * Reusable by query, execute, and any future command that accepts an agent ref.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAgentMessage = parseAgentMessage;
+/**
+ * Parse agent reference and message from CLI args array.
+ *
+ * Joins all args with a single space first, then splits on the first
+ * whitespace boundary so that both the "single-chunk" form
+ * (`'@claude 안녕'`) and the "separated" form (`'@claude', '안녕'`) produce
+ * identical results.
+ *
+ * Returns agentRef='' when no leading @mention is found — the caller should
+ * default to '@crewx' in that case.
+ */
+function parseAgentMessage(args) {
+    if (args.length === 0) {
+        return { agentRef: '', message: '' };
+    }
+    // Join all args so both forms are handled uniformly
+    const combined = args.join(' ').trim();
+    if (!combined) {
+        return { agentRef: '', message: '' };
+    }
+    // Only @mention form triggers explicit agent selection
+    if (combined.startsWith('@')) {
+        const spaceIdx = combined.indexOf(' ');
+        if (spaceIdx === -1) {
+            return { agentRef: combined, message: '' };
+        }
+        return {
+            agentRef: combined.slice(0, spaceIdx),
+            message: combined.slice(spaceIdx + 1).trim(),
+        };
+    }
+    // No leading @mention — entire input is the message; caller defaults to @crewx
+    return { agentRef: '', message: combined };
+}

package/dist/commands/parse-common-flags.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Common flag parser for query/execute commands.
+ *
+ * Supports both `--flag=value` and `--flag value` forms.
+ * Handles: --thread, --provider, --metadata, --verbose, --config/-c,
+ *          --output-format, --effort.
+ */
+export interface CommonFlags {
+    /** Thread name for conversation continuity. */
+    thread?: string;
+    /** Provider override (e.g., cli/claude). */
+    provider?: string;
+    /** Raw metadata JSON string. */
+    metadata?: string;
+    /** Enable verbose/debug output mode. */
+    verbose: boolean;
+    /** Config file path override. */
+    config?: string;
+    /** Output format (json | text | stream-json). */
+    outputFormat?: string;
+    /** Model effort level (high | medium | low). */
+    effort?: string;
+    /** Remaining non-flag arguments. */
+    rest: string[];
+}
+/**
+ * Parse common CLI flags from an args array.
+ * Returns parsed flags and remaining positional arguments.
+ */
+export declare function parseCommonFlags(args: string[]): CommonFlags;
+/**
+ * Parse metadata JSON string from --metadata flag.
+ * Returns empty object when no raw value provided.
+ * Throws Error on invalid JSON or non-object values (fail-fast).
+ */
+export declare function parseMetadata(raw?: string): Record<string, unknown>;