@crewx/cli 0.9.0-rc.9 → 0.9.0-rc.91

package/dist/bootstrap/codex-writable-roots.d.ts

@@ -33,6 +33,19 @@ export declare function escapeTomlBasicString(value: string): string;
  * Works for both `codex exec` and `codex exec resume` (config-override form).
  */
 export declare function buildCodexWritableRootArgs(crewxHome: string): string[];
+/**
+ * Create an `AdditionalArgsProvider` that skips Codex's git repository trust
+ * check for a resolved workspace.
+ *
+ * The workspace is resolved by the product layer, so an unavailable workspace
+ * must not fall back to the host cwd. The flag is independent of execution
+ * mode because it controls repository trust rather than filesystem access.
+ */
+export declare function createCodexSkipGitRepoCheckProvider(workspaceRoot: string | undefined): AdditionalArgsProvider;
+/**
+ * Compose product-layer argument providers while preserving their order.
+ */
+export declare function composeAdditionalArgsProviders(...providers: AdditionalArgsProvider[]): AdditionalArgsProvider;
 /**
  * Create an `AdditionalArgsProvider` (SDK extension point, WI-20260703-001)
  * that injects CrewX home as a Codex writable root for `workspace-write`

package/dist/bootstrap/codex-writable-roots.js

@@ -20,6 +20,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveCrewxHome = resolveCrewxHome;
 exports.escapeTomlBasicString = escapeTomlBasicString;
 exports.buildCodexWritableRootArgs = buildCodexWritableRootArgs;
+exports.createCodexSkipGitRepoCheckProvider = createCodexSkipGitRepoCheckProvider;
+exports.composeAdditionalArgsProviders = composeAdditionalArgsProviders;
 exports.createCodexWritableRootsProvider = createCodexWritableRootsProvider;
 const os_1 = require("os");
 const path_1 = require("path");
@@ -68,6 +70,29 @@ function buildCodexWritableRootArgs(crewxHome) {
 function isCodexProvider(ctx) {
     return ctx.providerId === 'codex' || ctx.providerStr === 'cli/codex';
 }
+/**
+ * Create an `AdditionalArgsProvider` that skips Codex's git repository trust
+ * check for a resolved workspace.
+ *
+ * The workspace is resolved by the product layer, so an unavailable workspace
+ * must not fall back to the host cwd. The flag is independent of execution
+ * mode because it controls repository trust rather than filesystem access.
+ */
+function createCodexSkipGitRepoCheckProvider(workspaceRoot) {
+    return (ctx) => {
+        if (!isCodexProvider(ctx))
+            return [];
+        if (!workspaceRoot)
+            return [];
+        return ['--skip-git-repo-check'];
+    };
+}
+/**
+ * Compose product-layer argument providers while preserving their order.
+ */
+function composeAdditionalArgsProviders(...providers) {
+    return (ctx) => providers.flatMap((provider) => provider(ctx));
+}
 /**
  * Create an `AdditionalArgsProvider` (SDK extension point, WI-20260703-001)
  * that injects CrewX home as a Codex writable root for `workspace-write`

package/dist/bootstrap/crewx-cli.js

@@ -40,6 +40,7 @@ async function createCliCrewx(configPath = process.env.CREWX_CONFIG ?? 'crewx.ya
     else {
         yamlPath = undefined;
     }
+    const skipRoot = yamlPath !== undefined ? (0, path_1.dirname)(absConfigPath) : undefined;
     // Run drizzle migrations once at bootstrap — plugin relies on this guarantee.
     const dbDir = (0, path_1.join)((0, os_1.homedir)(), '.crewx');
     (0, fs_1.mkdirSync)(dbDir, { recursive: true });
@@ -53,7 +54,7 @@ async function createCliCrewx(configPath = process.env.CREWX_CONFIG ?? 'crewx.ya
     }
     const crewx = await sdk_1.Crewx.loadYaml(yamlPath, {
         remoteFactory: createCliCrewx,
-        additionalArgsProvider: (0, codex_writable_roots_1.createCodexWritableRootsProvider)(),
+        additionalArgsProvider: (0, codex_writable_roots_1.composeAdditionalArgsProviders)((0, codex_writable_roots_1.createCodexWritableRootsProvider)(), (0, codex_writable_roots_1.createCodexSkipGitRepoCheckProvider)(skipRoot)),
     });
     (0, register_builtin_tools_1.registerBuiltinToolsIfNeeded)(crewx);
     await crewx.use(new plugins_1.ConversationPlugin());

package/dist/builtin.js

@@ -55,6 +55,7 @@ const BUILTIN_MAP = {
     dreaming: () => Promise.resolve().then(() => __importStar(require('@crewx/dreaming/cli'))),
     wi: () => Promise.resolve().then(() => __importStar(require('@crewx/wi/cli'))),
     chromex: () => Promise.resolve().then(() => __importStar(require('@crewx/chromex/cli'))),
+    notify: () => Promise.resolve().then(() => __importStar(require('@crewx/notify/cli'))),
 };
 exports.BUILTIN_COMMANDS = new Set(Object.keys(BUILTIN_MAP));
 // Load skill-tracer for observability (graceful degradation if unavailable)

package/dist/commands/agent.js

@@ -3,46 +3,11 @@
  * 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.
@@ -135,11 +100,9 @@ async function handleAgentPrompt(crewx, args) {
         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`);
@@ -197,27 +160,6 @@ async function handleAgent(args) {
             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

package/dist/commands/db.d.ts

@@ -6,4 +6,5 @@
  *   crewx db push --force        Apply without confirmation + reset migration history
  *   crewx db push --dry-run      Show preview only, no changes
  */
+export declare const TASK_LOG_MIGRATION_HELP = "Usage:\n  crewx db migrate-task-logs --dry-run [--db PATH]\n  crewx db migrate-task-logs --apply [--db PATH] [--batch-tasks N]\n  crewx db migrate-task-logs --verify [--db PATH]\n\nModes:\n  --dry-run  Read and validate legacy blobs without writing or creating a backup.\n  --apply    Create a consistent SQLite backup, then migrate one task per transaction.\n  --verify   Check source invariants, event sequences, counts, and orphan rows.\n\nApply policy:\n  Only blob tasks with status success, failed, or completed are migrated.\n  pending, running, paused, and unknown statuses are deferred for a later run.\n  There is no --force or --include-active option. Apply requires the estimated\n  database/event growth plus a 10 GiB free-space reserve.\n\nExit codes:\n  0  Completed with no malformed rows or invariant failures.\n  1  Safe tasks completed but a row/invariant failed, or apply was blocked.\n  2  Invalid command-line arguments.\n\nThe command never runs automatically at server startup and never runs VACUUM.";
 export declare function handleDb(args: string[]): Promise<void>;

package/dist/commands/db.js

@@ -11,12 +11,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_LOG_MIGRATION_HELP = void 0;
 exports.handleDb = handleDb;
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const readline_1 = __importDefault(require("readline"));
 const repository_1 = require("@crewx/sdk/repository");
 const repository_2 = require("@crewx/sdk/repository");
+const repository_3 = require("@crewx/sdk/repository");
+exports.TASK_LOG_MIGRATION_HELP = `Usage:
+  crewx db migrate-task-logs --dry-run [--db PATH]
+  crewx db migrate-task-logs --apply [--db PATH] [--batch-tasks N]
+  crewx db migrate-task-logs --verify [--db PATH]
+
+Modes:
+  --dry-run  Read and validate legacy blobs without writing or creating a backup.
+  --apply    Create a consistent SQLite backup, then migrate one task per transaction.
+  --verify   Check source invariants, event sequences, counts, and orphan rows.
+
+Apply policy:
+  Only blob tasks with status success, failed, or completed are migrated.
+  pending, running, paused, and unknown statuses are deferred for a later run.
+  There is no --force or --include-active option. Apply requires the estimated
+  database/event growth plus a 10 GiB free-space reserve.
+
+Exit codes:
+  0  Completed with no malformed rows or invariant failures.
+  1  Safe tasks completed but a row/invariant failed, or apply was blocked.
+  2  Invalid command-line arguments.
+
+The command never runs automatically at server startup and never runs VACUUM.`;
 function defaultDbPath() {
     return path_1.default.join(os_1.default.homedir(), '.crewx', 'crewx.db');
 }
@@ -57,6 +81,12 @@ function formatPreview(result, dbPath) {
 function hasChanges(result) {
     return result.created.length > 0 || result.altered.length > 0;
 }
+function formatStatusCounts(counts) {
+    const entries = Object.entries(counts ?? {});
+    return entries.length > 0
+        ? entries.map(([status, count]) => `${status}=${count}`).join(', ')
+        : '(none)';
+}
 function prompt(question) {
     const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {
@@ -68,13 +98,173 @@ function prompt(question) {
 }
 async function handleDb(args) {
     const subcommand = args[0];
+    if (subcommand === 'migrate-task-logs') {
+        await handleTaskLogMigration(args.slice(1));
+        return;
+    }
+    if (subcommand === '--help' || subcommand === '-h') {
+        console.log('Usage: crewx db push [--force] [--dry-run]');
+        console.log(exports.TASK_LOG_MIGRATION_HELP);
+        return;
+    }
     if (!subcommand || subcommand === 'push') {
         await handleDbPush(args.slice(subcommand === 'push' ? 1 : 0));
         return;
     }
     console.error(`Unknown db subcommand: ${subcommand}`);
     console.error('Usage: crewx db push [--force] [--dry-run]');
-    process.exit(1);
+    console.error(exports.TASK_LOG_MIGRATION_HELP);
+    process.exitCode = 2;
+}
+class TaskLogMigrationUsageError extends Error {
+}
+function parseTaskLogMigrationArgs(args) {
+    let mode;
+    let dbPath;
+    let batchTasks;
+    const setMode = (next) => {
+        if (mode)
+            throw new TaskLogMigrationUsageError('Choose exactly one of --dry-run, --apply, or --verify.');
+        mode = next;
+    };
+    const requireValue = (args, index, flag) => {
+        const value = args[index + 1];
+        if (!value || value.startsWith('--'))
+            throw new TaskLogMigrationUsageError(`${flag} requires a value.`);
+        return value;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--help' || arg === '-h') {
+            throw new TaskLogMigrationUsageError(exports.TASK_LOG_MIGRATION_HELP);
+        }
+        if (arg === '--dry-run') {
+            setMode('dry-run');
+            continue;
+        }
+        if (arg === '--apply') {
+            setMode('apply');
+            continue;
+        }
+        if (arg === '--verify') {
+            setMode('verify');
+            continue;
+        }
+        if (arg === '--db') {
+            dbPath = requireValue(args, index, '--db');
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--db=')) {
+            dbPath = arg.slice('--db='.length);
+            if (!dbPath)
+                throw new TaskLogMigrationUsageError('--db requires a value.');
+            continue;
+        }
+        if (arg === '--batch-tasks') {
+            const value = requireValue(args, index, '--batch-tasks');
+            const parsed = Number(value);
+            if (!Number.isSafeInteger(parsed) || parsed < 1) {
+                throw new TaskLogMigrationUsageError('--batch-tasks must be a positive integer.');
+            }
+            batchTasks = parsed;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--batch-tasks=')) {
+            const value = arg.slice('--batch-tasks='.length);
+            const parsed = Number(value);
+            if (!Number.isSafeInteger(parsed) || parsed < 1) {
+                throw new TaskLogMigrationUsageError('--batch-tasks must be a positive integer.');
+            }
+            batchTasks = parsed;
+            continue;
+        }
+        throw new TaskLogMigrationUsageError(`Unknown option: ${arg}`);
+    }
+    if (!mode)
+        throw new TaskLogMigrationUsageError('Choose one of --dry-run, --apply, or --verify.');
+    if (batchTasks !== undefined && mode !== 'apply') {
+        throw new TaskLogMigrationUsageError('--batch-tasks is only valid with --apply.');
+    }
+    return { mode, dbPath, batchTasks };
+}
+function formatMigrationReport(report) {
+    const modeLabel = report.mode === 'dry-run' ? 'Dry-run' : report.mode === 'apply' ? 'Apply' : 'Verify';
+    const lines = [
+        `[crewx] Task-log migration — ${modeLabel}`,
+        `  Database: ${report.dbPath}`,
+        `  Tasks scanned: ${report.taskCount}`,
+        `  Blob candidates: ${report.candidateTaskCount}`,
+        `  Eligible terminal blobs: ${report.eligibleTaskCount}`,
+        `  Status counts: ${formatStatusCounts(report.statusCounts)}`,
+        `  Deferred blob tasks: ${report.deferredTaskCount}`,
+        `  Deferred statuses: ${formatStatusCounts(report.deferredStatusCounts)}`,
+        `  Entries: ${report.entryCount}`,
+        `  Source bytes: ${report.sourceBytes}`,
+        `  Estimated free-space need: ${report.estimatedFreeSpaceBytes}`,
+        `  Required free space (with reserve): ${report.requiredFreeSpaceBytes}`,
+        `  Available free space: ${report.availableFreeSpaceBytes}`,
+        `  Free-space gate: ${report.freeSpaceGatePassed ? 'PASS' : 'FAIL'}`,
+        `  Migrated: ${report.migratedTasks} task(s), ${report.migratedEntries} entr${report.migratedEntries === 1 ? 'y' : 'ies'}`,
+        `  Skipped event-source tasks: ${report.skippedTasks}`,
+        `  Failed tasks: ${report.failedTasks}`,
+        `  Logical source bytes removed: ${report.logicalSourceBytesRemoved}`,
+    ];
+    if (report.remainingTaskCount !== undefined)
+        lines.push(`  Remaining blob tasks: ${report.remainingTaskCount}`);
+    if (report.backupPath) {
+        lines.push(`  Backup: ${report.backupPath}`);
+        if (report.backupMethod)
+            lines.push(`  Backup method: ${report.backupMethod}`);
+    }
+    if (report.verification) {
+        lines.push(`  Event rows checked: ${report.verification.eventCount}`);
+        lines.push(`  Verification issues: ${report.verification.issues.length}`);
+    }
+    if (report.blockedReason)
+        lines.push(`  Blocked: ${report.blockedReason}`);
+    for (const warning of report.warnings ?? [])
+        lines.push(`  Warning: ${warning}`);
+    return lines.join('\n');
+}
+async function handleTaskLogMigration(args) {
+    let parsed;
+    try {
+        parsed = parseTaskLogMigrationArgs(args);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message === exports.TASK_LOG_MIGRATION_HELP) {
+            console.log(message);
+        }
+        else {
+            console.error(message);
+            console.error(exports.TASK_LOG_MIGRATION_HELP);
+            process.exitCode = 2;
+        }
+        return;
+    }
+    try {
+        const report = await (0, repository_3.runTaskLogMigration)(parsed);
+        console.log(formatMigrationReport(report));
+        if (!report.ok) {
+            if (report.blockedReason)
+                console.error(report.blockedReason);
+            const failures = report.failures ?? report.malformedRows ?? [];
+            for (const failure of failures) {
+                console.error(`  ${failure.taskId}: ${failure.reason}`);
+            }
+            process.exitCode = 1;
+        }
+        else {
+            process.exitCode = 0;
+        }
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
 }
 async function handleDbPush(args) {
     const force = args.includes('--force');

package/dist/commands/doctor.d.ts

@@ -6,7 +6,60 @@
  *   crewx doctor                  Run full diagnosis
  *   crewx doctor --config <path>  Use specific config file
  */
+interface DiagnosticResult {
+    name: string;
+    status: 'success' | 'warning' | 'error';
+    message: string;
+    details?: string;
+}
+export interface CliProviderInfo {
+    cmd: string;
+    install: string;
+}
+export interface DoctorArtifact {
+    directory: string;
+    sizeBytes: number;
+    details: string[];
+}
+export interface NpxCacheReport {
+    cacheRoot: string;
+    zeroByteLockfileDirectories: DoctorArtifact[];
+    staleFileCacheDirectories: DoctorArtifact[];
+    cleanableDirectories: DoctorArtifact[];
+}
+export interface HookCommandIssue {
+    provider: 'claude' | 'codex';
+    settingsPath: string;
+    command: string;
+    reason: 'launcher' | 'non-absolute';
+}
+export interface HookCommandReport {
+    inspectedFiles: string[];
+    issues: HookCommandIssue[];
+}
+export interface CrewxShimReport {
+    shimRoot: string;
+    currentFingerprint?: string;
+    staleDirectories: Array<DoctorArtifact & {
+        fingerprint: string;
+    }>;
+}
+/** CLI diagnostics keyed by the bare provider name used in PROVIDER_ORDER. */
+export declare const CLI_PROVIDER_INFO: Record<string, CliProviderInfo>;
+/** Format a byte count for diagnostic output. */
+export declare function formatBytes(bytes: number): string;
+/** Inspect npm's persistent `_npx` cache without modifying it. */
+export declare function inspectNpxCache(cacheRoot?: string): NpxCacheReport;
+/** Inspect installed CrewX hooks without rewriting provider settings. */
+export declare function inspectHookCommands(projectRoot: string): HookCommandReport;
+/** Inspect orphaned CrewX PATH shim directories without modifying them. */
+export declare function inspectCrewxShims(crewxHome?: string, resolvedFingerprint?: string | undefined): CrewxShimReport;
+/**
+ * Check CLI provider availability in the canonical PROVIDER_ORDER.
+ */
+export declare function checkCliProviders(): DiagnosticResult[];
 /**
  * Handle `crewx doctor` command.
  */
 export declare function handleDoctor(args: string[]): Promise<void>;
+export {};