mcoda 0.1.2 → 0.1.4

package/dist/commands/telemetry/TelemetryCommands.js

@@ -0,0 +1,313 @@
+import path from "node:path";
+import { JobService, TelemetryService, WorkspaceResolver } from "@mcoda/core";
+const tokensUsage = `mcoda tokens \\
+  [--workspace-root <PATH>] \\
+  [--project <PROJECT_KEY|ID>] \\
+  [--agent <NAME|ID>] \\
+  [--command <COMMAND_NAME>] \\
+  [--job <JOB_ID>] \\
+  [--since <ISO_TIMESTAMP|DURATION>] \\
+  [--until <ISO_TIMESTAMP>] \\
+  [--group-by <project|agent|command|day|model|job|action>] \\
+  [--format <table|json>]`;
+const telemetryUsage = `mcoda telemetry <show|opt-out|opt-in> \\
+  [--workspace-root <PATH>] \\
+  [--format <table|json>] \\
+  [--strict] (opt-out only)`;
+const normalizeGroupBy = (input) => {
+    const allowed = new Set(["project", "agent", "command", "day", "model", "job", "action"]);
+    const selected = (input ?? []).filter((dim) => allowed.has(dim));
+    if (selected.length === 0) {
+        return ["project", "command", "agent"];
+    }
+    return Array.from(new Set(selected));
+};
+export const parseTokensArgs = (argv) => {
+    const parsed = {
+        groupBy: [],
+        format: "table",
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        switch (arg) {
+            case "--workspace-root":
+            case "--workspace":
+                parsed.workspaceRoot = argv[i + 1] ? path.resolve(argv[i + 1]) : undefined;
+                i += 1;
+                break;
+            case "--project":
+                parsed.project = argv[i + 1];
+                i += 1;
+                break;
+            case "--agent":
+                parsed.agent = argv[i + 1];
+                i += 1;
+                break;
+            case "--command":
+                parsed.command = argv[i + 1];
+                i += 1;
+                break;
+            case "--job":
+                parsed.job = argv[i + 1];
+                i += 1;
+                break;
+            case "--since":
+                parsed.since = argv[i + 1];
+                i += 1;
+                break;
+            case "--until":
+                parsed.until = argv[i + 1];
+                i += 1;
+                break;
+            case "--group-by":
+                parsed.groupBy = (argv[i + 1] ?? "").split(",").map((v) => v.trim()).filter(Boolean);
+                i += 1;
+                break;
+            case "--format":
+                parsed.format = argv[i + 1] === "json" ? "json" : "table";
+                i += 1;
+                break;
+            case "--help":
+            case "-h":
+                // eslint-disable-next-line no-console
+                console.log(tokensUsage);
+                process.exit(0);
+                break;
+            default:
+                if (arg.startsWith("--group-by=")) {
+                    parsed.groupBy = arg
+                        .split("=")[1]
+                        .split(",")
+                        .map((v) => v.trim())
+                        .filter(Boolean);
+                }
+                else if (arg.startsWith("--format=")) {
+                    parsed.format = arg.endsWith("json") ? "json" : "table";
+                }
+                else if (arg.startsWith("--job=")) {
+                    parsed.job = arg.split("=")[1];
+                }
+                break;
+        }
+    }
+    parsed.groupBy = normalizeGroupBy(parsed.groupBy);
+    return parsed;
+};
+export const parseTelemetryArgs = (argv) => {
+    let subcommand = "show";
+    const parsed = {
+        subcommand,
+        format: "table",
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (!arg.startsWith("--") && i === 0) {
+            subcommand = arg ?? "show";
+            parsed.subcommand = subcommand;
+            continue;
+        }
+        switch (arg) {
+            case "--workspace-root":
+            case "--workspace":
+                parsed.workspaceRoot = argv[i + 1] ? path.resolve(argv[i + 1]) : undefined;
+                i += 1;
+                break;
+            case "--format":
+                parsed.format = argv[i + 1] === "json" ? "json" : "table";
+                i += 1;
+                break;
+            case "--strict":
+                parsed.strict = true;
+                break;
+            case "--help":
+            case "-h":
+                // eslint-disable-next-line no-console
+                console.log(telemetryUsage);
+                process.exit(0);
+                break;
+            default:
+                if (arg.startsWith("--format=")) {
+                    parsed.format = arg.endsWith("json") ? "json" : "table";
+                }
+                break;
+        }
+    }
+    return parsed;
+};
+const pad = (value, width) => value.padEnd(width, " ");
+const formatTable = (headers, rows) => {
+    const widths = headers.map((header, idx) => Math.max(header.length, ...rows.map((row) => (row[idx] ?? "").length)));
+    const headerLine = headers.map((h, idx) => pad(h, widths[idx])).join(" | ");
+    const sepLine = widths.map((w) => "-".repeat(w)).join("-+-");
+    const body = rows.map((row) => row.map((cell, idx) => pad(cell ?? "", widths[idx])).join(" | ")).join("\n");
+    return [headerLine, sepLine, body].filter(Boolean).join("\n");
+};
+const formatNumber = (value, digits = 0) => {
+    if (value === null || value === undefined)
+        return "-";
+    if (digits > 0)
+        return value.toFixed(digits);
+    return `${value}`;
+};
+const renderTokensTable = (rows, groupBy) => {
+    const dims = new Set(groupBy);
+    const headers = [];
+    const extractors = [];
+    if (dims.has("project")) {
+        headers.push("PROJECT");
+        extractors.push((row) => row.project_id ?? "-");
+    }
+    if (dims.has("command")) {
+        headers.push("COMMAND");
+        extractors.push((row) => row.command_name ?? "-");
+    }
+    if (dims.has("agent")) {
+        headers.push("AGENT");
+        extractors.push((row) => row.agent_id ?? "-");
+    }
+    if (dims.has("model")) {
+        headers.push("MODEL");
+        extractors.push((row) => row.model_name ?? "-");
+    }
+    if (dims.has("day")) {
+        headers.push("DAY");
+        extractors.push((row) => row.day ?? "-");
+    }
+    if (dims.has("job")) {
+        headers.push("JOB");
+        extractors.push((row) => row.job_id ?? "-");
+    }
+    if (dims.has("action")) {
+        headers.push("ACTION");
+        extractors.push((row) => row.action ?? "-");
+    }
+    headers.push("CALLS", "TOKENS_IN", "TOKENS_OUT", "TOKENS_TOTAL", "COST");
+    extractors.push((row) => `${row.calls}`, (row) => formatNumber(row.tokens_prompt), (row) => formatNumber(row.tokens_completion), (row) => formatNumber(row.tokens_total), (row) => formatNumber(row.cost_estimate, 4));
+    const tableRows = rows.map((row) => extractors.map((fn) => fn(row)));
+    // eslint-disable-next-line no-console
+    console.log(formatTable(headers, tableRows));
+};
+const renderTelemetryConfig = (config) => {
+    const rows = [
+        ["Local recording", config.localRecording ? "enabled" : "disabled"],
+        ["Remote export", config.remoteExport ? "enabled" : "disabled"],
+        ["Strict mode", config.strict ? "on" : "off"],
+        ["Config path", config.configPath],
+    ];
+    // eslint-disable-next-line no-console
+    console.log(formatTable(["SETTING", "VALUE"], rows));
+};
+export class TelemetryCommands {
+    static async runTokens(argv) {
+        const parsed = parseTokensArgs(argv);
+        const workspace = await WorkspaceResolver.resolveWorkspace({
+            cwd: process.cwd(),
+            explicitWorkspace: parsed.workspaceRoot,
+        });
+        const jobService = new JobService(workspace, undefined, { noTelemetry: true });
+        const commandRun = await jobService.startCommandRun("tokens", parsed.project);
+        const telemetry = await TelemetryService.create(workspace);
+        try {
+            const config = await telemetry.getConfig();
+            const summary = await telemetry.getSummary({
+                projectKey: parsed.project,
+                agent: parsed.agent,
+                command: parsed.command,
+                jobId: parsed.job,
+                since: parsed.since,
+                until: parsed.until,
+                groupBy: parsed.groupBy,
+            });
+            if (!config.localRecording && summary.length === 0) {
+                // eslint-disable-next-line no-console
+                console.log("Local token tracking is disabled; no data available.");
+                return;
+            }
+            if (summary.length === 0) {
+                // eslint-disable-next-line no-console
+                console.log("No telemetry data for the selected filters/time window.");
+                await jobService.finishCommandRun(commandRun.id, "succeeded");
+                return;
+            }
+            if (parsed.format === "json") {
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify(summary, null, 2));
+                await jobService.finishCommandRun(commandRun.id, "succeeded");
+                return;
+            }
+            renderTokensTable(summary, parsed.groupBy);
+            await jobService.finishCommandRun(commandRun.id, "succeeded");
+        }
+        catch (error) {
+            await jobService.finishCommandRun(commandRun.id, "failed", error.message);
+            const message = error.message ?? "Unknown error";
+            if (message.includes("workspace DB") || message.includes("workspace")) {
+                // eslint-disable-next-line no-console
+                console.error("No mcoda workspace/DB found. Run mcoda init or create-tasks in this repo first.");
+            }
+            else {
+                // eslint-disable-next-line no-console
+                console.error(`tokens failed: ${message}`);
+            }
+            process.exitCode = 1;
+        }
+        finally {
+            await jobService.close();
+            await telemetry.close();
+        }
+    }
+    static async runTelemetry(argv) {
+        const parsed = parseTelemetryArgs(argv);
+        const workspace = await WorkspaceResolver.resolveWorkspace({
+            cwd: process.cwd(),
+            explicitWorkspace: parsed.workspaceRoot,
+        });
+        const jobService = new JobService(workspace, undefined, { noTelemetry: true });
+        const commandRun = await jobService.startCommandRun(`telemetry-${parsed.subcommand}`, undefined);
+        const telemetry = await TelemetryService.create(workspace, { allowMissingTelemetry: true });
+        try {
+            if (parsed.subcommand === "show") {
+                const config = await telemetry.getConfig();
+                if (parsed.format === "json") {
+                    // eslint-disable-next-line no-console
+                    console.log(JSON.stringify(config, null, 2));
+                }
+                else {
+                    renderTelemetryConfig(config);
+                }
+                await jobService.finishCommandRun(commandRun.id, "succeeded");
+                return;
+            }
+            if (parsed.subcommand === "opt-out") {
+                const config = await telemetry.optOut(parsed.strict ?? false);
+                // eslint-disable-next-line no-console
+                console.log(`Telemetry opted out.${config.strict ? " Strict mode enabled; local recording disabled." : " Local recording still enabled."}`);
+                await jobService.finishCommandRun(commandRun.id, "succeeded");
+                return;
+            }
+            if (parsed.subcommand === "opt-in") {
+                const config = await telemetry.optIn();
+                // eslint-disable-next-line no-console
+                console.log(`Telemetry opted in. Local recording ${config.localRecording ? "enabled" : "disabled"}, remote export ${config.remoteExport ? "enabled" : "disabled"}.`);
+                await jobService.finishCommandRun(commandRun.id, "succeeded");
+            }
+        }
+        catch (error) {
+            await jobService.finishCommandRun(commandRun.id, "failed", error.message);
+            const message = error.message ?? "Unknown error";
+            if (message.includes("workspace DB") || message.includes("workspace")) {
+                // eslint-disable-next-line no-console
+                console.error("No mcoda workspace/DB found. Run mcoda init or create-tasks in this repo first.");
+            }
+            else {
+                // eslint-disable-next-line no-console
+                console.error(`telemetry ${parsed.subcommand} failed: ${message}`);
+            }
+            process.exitCode = 1;
+        }
+        finally {
+            await jobService.close();
+            await telemetry.close();
+        }
+    }
+}

package/dist/commands/update/UpdateCommands.d.ts

@@ -0,0 +1,4 @@
+export declare class UpdateCommands {
+    static run(argv: string[]): Promise<void>;
+}
+//# sourceMappingURL=UpdateCommands.d.ts.map

package/dist/commands/update/UpdateCommands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateCommands.d.ts","sourceRoot":"","sources":["../../../src/commands/update/UpdateCommands.ts"],"names":[],"mappings":"AA6GA,qBAAa,cAAc;WACZ,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CA8LhD"}

package/dist/commands/update/UpdateCommands.js

@@ -0,0 +1,280 @@
+import { createRequire } from "node:module";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { SystemUpdateService } from "@mcoda/core";
+const usage = `mcoda update \\
+  [--check] \\
+  [--channel <stable|beta|nightly>] \\
+  [--version <SEMVER>] \\
+  [--force] \\
+  [--json] \\
+  [--quiet]`;
+const readCliVersion = () => {
+    const require = createRequire(import.meta.url);
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const pkg = require("../../package.json");
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+};
+const parseUpdateArgs = (argv) => {
+    const parsed = {
+        checkOnly: false,
+        force: false,
+        json: false,
+        quiet: false,
+        debug: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        switch (arg) {
+            case "--check":
+                parsed.checkOnly = true;
+                break;
+            case "--channel":
+                parsed.channel = argv[i + 1];
+                i += 1;
+                break;
+            case "--version":
+                parsed.version = argv[i + 1];
+                i += 1;
+                break;
+            case "--force":
+                parsed.force = true;
+                break;
+            case "--json":
+                parsed.json = true;
+                break;
+            case "--quiet":
+                parsed.quiet = true;
+                break;
+            case "--debug":
+                parsed.debug = true;
+                break;
+            case "--workspace":
+            case "--workspace-root":
+                i += 1;
+                break;
+            case "--help":
+            case "-h":
+                // eslint-disable-next-line no-console
+                console.log(usage);
+                process.exit(0);
+                break;
+            case "--no-color":
+            case "--no-telemetry":
+                // ignored global flags
+                break;
+            default:
+                if (arg.startsWith("--channel=")) {
+                    parsed.channel = arg.split("=")[1];
+                }
+                else if (arg.startsWith("--version=")) {
+                    parsed.version = arg.split("=")[1];
+                }
+                else {
+                    throw new Error(`Unknown flag: ${arg}\n\n${usage}`);
+                }
+                break;
+        }
+    }
+    return parsed;
+};
+const isValidVersion = (value) => {
+    if (!value)
+        return true;
+    return /^\d+\.\d+\.\d+(-[\w.-]+)?$/.test(value);
+};
+const confirmInteractive = async (prompt) => {
+    const rl = readline.createInterface({ input, output });
+    const answer = await rl.question(prompt);
+    rl.close();
+    return /^y(es)?$/i.test(answer.trim());
+};
+export class UpdateCommands {
+    static async run(argv) {
+        let runId;
+        let service;
+        let exitCode = 0;
+        let errorSummary = null;
+        let result;
+        const cliVersion = readCliVersion();
+        try {
+            const parsed = parseUpdateArgs(argv);
+            if (!isValidVersion(parsed.version)) {
+                throw new Error(`Invalid --version value (expected semver): ${parsed.version}`);
+            }
+            service = await SystemUpdateService.create();
+            runId = await service.startRun({
+                cliVersion,
+                channel: parsed.channel ?? "stable",
+                versionOverride: parsed.version,
+                checkOnly: parsed.checkOnly,
+                force: parsed.force,
+            });
+            const channel = await service.resolveChannel(parsed.channel);
+            if (parsed.channel) {
+                await service.savePreferredChannel(channel);
+            }
+            let check;
+            try {
+                check = await service.checkUpdate(channel);
+            }
+            catch (error) {
+                errorSummary = error instanceof Error ? error.message : String(error);
+                exitCode = 4;
+                if (!parsed.quiet) {
+                    // eslint-disable-next-line no-console
+                    console.error(errorSummary);
+                }
+                return;
+            }
+            const targetVersion = parsed.version ?? check.info.latestVersion;
+            const npmCommand = `npm install -g mcoda@${targetVersion}`;
+            result = { check, targetVersion, npmCommand };
+            if (parsed.checkOnly) {
+                if (parsed.json) {
+                    // eslint-disable-next-line no-console
+                    console.log(JSON.stringify({ ...check.info, channel: check.channel, checkedAt: check.checkedAt }, null, 2));
+                }
+                else if (!parsed.quiet) {
+                    const summary = `Current: ${check.info.currentVersion}, Latest (channel=${check.channel}): ${check.info.latestVersion}, updateAvailable: ${check.info.updateAvailable}`;
+                    // eslint-disable-next-line no-console
+                    console.log(summary);
+                    if (check.info.notes) {
+                        // eslint-disable-next-line no-console
+                        console.log(check.info.notes);
+                    }
+                }
+                return;
+            }
+            const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+            const requiresForce = !interactive || Boolean(process.env.CI);
+            if (requiresForce && !parsed.force) {
+                exitCode = 2;
+                errorSummary = "Non-interactive update requires --force.";
+                if (!parsed.quiet) {
+                    // eslint-disable-next-line no-console
+                    console.error(`${errorSummary} Planned npm command: ${npmCommand}`);
+                }
+                return;
+            }
+            if (interactive && !parsed.force) {
+                const proceed = await confirmInteractive(`Update mcoda from ${check.info.currentVersion} -> ${targetVersion} on channel ${channel}? [y/N] `);
+                if (!proceed) {
+                    exitCode = 2;
+                    errorSummary = "Update cancelled by user.";
+                    return;
+                }
+            }
+            if (!check.info.updateAvailable && !parsed.version) {
+                if (!parsed.quiet) {
+                    // eslint-disable-next-line no-console
+                    console.log("Already up to date.");
+                }
+                await service.recordApplyState(check.info, channel, check.info.currentVersion);
+                return;
+            }
+            if (!parsed.quiet) {
+                // eslint-disable-next-line no-console
+                console.log(`Applying update via API (npm command: ${npmCommand})...`);
+            }
+            let applyResponse;
+            let npmFallbackSucceeded = false;
+            try {
+                applyResponse = await service.applyUpdate(channel);
+                result = { ...result, applyResponse };
+            }
+            catch (error) {
+                errorSummary = error instanceof Error ? error.message : String(error);
+                try {
+                    const npmResult = await service.runNpmInstall(targetVersion, { quiet: parsed.quiet });
+                    result = { ...result, npmResult };
+                    if (npmResult.code !== 0) {
+                        exitCode = 6;
+                        errorSummary = `npm install exited with code ${npmResult.code}`;
+                    }
+                    else {
+                        npmFallbackSucceeded = true;
+                        exitCode = 0;
+                        errorSummary = null;
+                    }
+                }
+                catch (installError) {
+                    exitCode = 6;
+                    errorSummary = installError instanceof Error ? installError.message : String(installError);
+                }
+            }
+            if (applyResponse) {
+                if (applyResponse.status === "already_up_to_date") {
+                    if (!parsed.quiet) {
+                        // eslint-disable-next-line no-console
+                        console.log("Already up to date.");
+                    }
+                    exitCode = 0;
+                }
+                else if (applyResponse.status === "started") {
+                    if (!parsed.quiet) {
+                        // eslint-disable-next-line no-console
+                        console.log(`Update started. Logs: ${applyResponse.logFile ?? "n/a"}`);
+                    }
+                }
+                else if (applyResponse.status === "completed") {
+                    if (!parsed.quiet) {
+                        // eslint-disable-next-line no-console
+                        console.log(`Update completed. Logs: ${applyResponse.logFile ?? "n/a"}`);
+                    }
+                }
+                await service.recordApplyState(check.info, channel, targetVersion);
+                if (parsed.json) {
+                    // eslint-disable-next-line no-console
+                    console.log(JSON.stringify({
+                        status: applyResponse.status,
+                        logFile: applyResponse.logFile,
+                        targetVersion,
+                        channel,
+                        npmCommand,
+                    }, null, 2));
+                }
+            }
+            else if (npmFallbackSucceeded) {
+                // npm fallback succeeded
+                await service.recordApplyState(check.info, channel, targetVersion);
+                if (parsed.json) {
+                    // eslint-disable-next-line no-console
+                    console.log(JSON.stringify({ status: "completed", targetVersion, channel, npmCommand }, null, 2));
+                }
+            }
+            else if (exitCode === 4 && !parsed.quiet) {
+                // eslint-disable-next-line no-console
+                console.error(`Update apply failed; run manually: ${npmCommand}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.error(message);
+            exitCode = exitCode || 1;
+            errorSummary = message;
+        }
+        finally {
+            if (service && runId) {
+                await service.finishRun(runId, {
+                    status: exitCode === 0 ? "succeeded" : "failed",
+                    exitCode,
+                    errorSummary,
+                    result,
+                });
+            }
+            if (service) {
+                await service.close();
+            }
+            if (exitCode) {
+                process.exitCode = exitCode;
+            }
+        }
+    }
+}

package/dist/commands/work/WorkOnTasksCommand.d.ts

@@ -0,0 +1,21 @@
+interface ParsedArgs {
+    workspaceRoot?: string;
+    projectKey?: string;
+    epicKey?: string;
+    storyKey?: string;
+    taskKeys: string[];
+    statusFilter: string[];
+    limit?: number;
+    parallel?: number;
+    noCommit: boolean;
+    dryRun: boolean;
+    agentName?: string;
+    agentStream?: boolean;
+    json: boolean;
+}
+export declare const parseWorkOnTasksArgs: (argv: string[]) => ParsedArgs;
+export declare class WorkOnTasksCommand {
+    static run(argv: string[]): Promise<void>;
+}
+export {};
+//# sourceMappingURL=WorkOnTasksCommand.d.ts.map

package/dist/commands/work/WorkOnTasksCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkOnTasksCommand.d.ts","sourceRoot":"","sources":["../../../src/commands/work/WorkOnTasksCommand.ts"],"names":[],"mappings":"AAGA,UAAU,UAAU;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,OAAO,CAAC;CACf;AA+BD,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,EAAE,KAAG,UA0HrD,CAAC;AAEF,qBAAa,kBAAkB;WAChB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CA0FhD"}