mcoda 0.1.2 → 0.1.4

package/dist/commands/openapi/OpenapiCommands.js

@@ -0,0 +1,157 @@
+import path from "node:path";
+import { createRequire } from "node:module";
+import { OpenApiService, WorkspaceResolver } from "@mcoda/core";
+const usage = "mcoda openapi-from-docs [--workspace-root <PATH>] [--agent <NAME>] [--agent-stream <true|false>] [--force] [--dry-run] [--validate-only] [--no-telemetry]";
+const parseBooleanFlag = (value, defaultValue) => {
+    if (value === undefined)
+        return defaultValue;
+    const normalized = value.toLowerCase();
+    if (["false", "0", "no"].includes(normalized))
+        return false;
+    if (["true", "1", "yes"].includes(normalized))
+        return true;
+    return defaultValue;
+};
+export const parseOpenapiArgs = (argv) => {
+    let workspaceRoot;
+    let agentName;
+    let agentStream;
+    let force = false;
+    let dryRun = false;
+    let validateOnly = false;
+    let noTelemetry = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg.startsWith("--agent-stream=")) {
+            const [, raw] = arg.split("=", 2);
+            agentStream = parseBooleanFlag(raw, true);
+            continue;
+        }
+        switch (arg) {
+            case "--workspace-root":
+                workspaceRoot = argv[i + 1] ? path.resolve(argv[i + 1]) : undefined;
+                i += 1;
+                break;
+            case "--agent":
+                agentName = argv[i + 1];
+                i += 1;
+                break;
+            case "--agent-stream": {
+                const next = argv[i + 1];
+                if (next && !next.startsWith("--")) {
+                    agentStream = parseBooleanFlag(next, true);
+                    i += 1;
+                }
+                else {
+                    agentStream = true;
+                }
+                break;
+            }
+            case "--force":
+                force = true;
+                break;
+            case "--dry-run":
+                dryRun = true;
+                break;
+            case "--validate-only":
+                validateOnly = true;
+                break;
+            case "--no-telemetry":
+                noTelemetry = true;
+                break;
+            case "--help":
+            case "-h":
+                // eslint-disable-next-line no-console
+                console.log(usage);
+                process.exit(0);
+                break;
+            default:
+                break;
+        }
+    }
+    return {
+        workspaceRoot,
+        agentName,
+        agentStream: agentStream ?? true,
+        force,
+        dryRun,
+        validateOnly,
+        noTelemetry,
+    };
+};
+const readCliVersion = () => {
+    const require = createRequire(import.meta.url);
+    try {
+        // Resolve the package version from the CLI package.json
+        // 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";
+    }
+};
+export class OpenapiCommands {
+    static async run(argv) {
+        const parsed = parseOpenapiArgs(argv);
+        const workspace = await WorkspaceResolver.resolveWorkspace({
+            cwd: process.cwd(),
+            explicitWorkspace: parsed.workspaceRoot,
+        });
+        const service = await OpenApiService.create(workspace, { noTelemetry: parsed.noTelemetry });
+        try {
+            const cliVersion = readCliVersion();
+            const shouldStream = parsed.agentStream;
+            const onToken = shouldStream ? (token) => process.stdout.write(token) : undefined;
+            const result = await service.generateFromDocs({
+                workspace,
+                agentName: parsed.agentName,
+                agentStream: parsed.agentStream,
+                force: parsed.force,
+                dryRun: parsed.dryRun,
+                validateOnly: parsed.validateOnly,
+                cliVersion,
+                onToken,
+            });
+            if (shouldStream) {
+                // separate streamed content from the summary
+                // eslint-disable-next-line no-console
+                console.log("\n");
+            }
+            // eslint-disable-next-line no-console
+            console.log(`OpenAPI job ${result.jobId} ${parsed.validateOnly ? "validated" : "completed"}.`);
+            if (result.outputPath) {
+                // eslint-disable-next-line no-console
+                console.log(`Output: ${result.outputPath}${parsed.dryRun ? " (dry run, not written)" : ""}`);
+            }
+            else if (parsed.dryRun) {
+                // eslint-disable-next-line no-console
+                console.log("Dry run: spec not written to disk.");
+            }
+            if (result.docdexId) {
+                // eslint-disable-next-line no-console
+                console.log(`Docdex ID: ${result.docdexId}`);
+            }
+            if (result.warnings.length) {
+                const banner = result.warnings.map((w) => `! ${w}`).join("\n");
+                // eslint-disable-next-line no-console
+                console.warn(banner);
+            }
+            if (parsed.dryRun) {
+                // eslint-disable-next-line no-console
+                console.log("\n--- Generated OpenAPI ---\n");
+                // eslint-disable-next-line no-console
+                console.log(result.spec);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.error(`ERROR: ${message}`);
+            process.exitCode = 1;
+        }
+        finally {
+            await service.close();
+        }
+    }
+}

package/dist/commands/planning/CreateTasksCommand.d.ts

@@ -0,0 +1,17 @@
+interface ParsedArgs {
+    workspaceRoot?: string;
+    projectKey?: string;
+    agentName?: string;
+    agentStream: boolean;
+    maxEpics?: number;
+    maxStoriesPerEpic?: number;
+    maxTasksPerStory?: number;
+    quiet?: boolean;
+    inputs: string[];
+}
+export declare const parseCreateTasksArgs: (argv: string[]) => ParsedArgs;
+export declare class CreateTasksCommand {
+    static run(argv: string[]): Promise<void>;
+}
+export {};
+//# sourceMappingURL=CreateTasksCommand.d.ts.map

package/dist/commands/planning/CreateTasksCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateTasksCommand.d.ts","sourceRoot":"","sources":["../../../src/commands/planning/CreateTasksCommand.ts"],"names":[],"mappings":"AAIA,UAAU,UAAU;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAYD,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,EAAE,KAAG,UA8ErD,CAAC;AAEF,qBAAa,kBAAkB;WAChB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAyChD"}

package/dist/commands/planning/CreateTasksCommand.js

@@ -0,0 +1,134 @@
+import path from "node:path";
+import { CreateTasksService, WorkspaceResolver } from "@mcoda/core";
+import { PathHelper } from "@mcoda/shared";
+const usage = `mcoda create-tasks [INPUT...] [--workspace-root <path>] [--project-key <key>] [--agent <name>] [--agent-stream [true|false]] [--max-epics N] [--max-stories-per-epic N] [--max-tasks-per-story N] [--quiet]`;
+const parseBooleanFlag = (value, defaultValue) => {
+    if (value === undefined)
+        return defaultValue;
+    const normalized = value.toLowerCase();
+    if (["false", "0", "no"].includes(normalized))
+        return false;
+    if (["true", "1", "yes"].includes(normalized))
+        return true;
+    return defaultValue;
+};
+export const parseCreateTasksArgs = (argv) => {
+    const inputs = [];
+    let workspaceRoot;
+    let projectKey;
+    let agentName;
+    let agentStream;
+    let maxEpics;
+    let maxStoriesPerEpic;
+    let maxTasksPerStory;
+    let quiet = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg.startsWith("--")) {
+            switch (arg) {
+                case "--workspace-root":
+                    workspaceRoot = argv[i + 1] ? path.resolve(argv[i + 1]) : undefined;
+                    i += 1;
+                    break;
+                case "--project-key":
+                case "--project":
+                    projectKey = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--agent":
+                    agentName = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--agent-stream": {
+                    const next = argv[i + 1];
+                    if (next && !next.startsWith("--")) {
+                        agentStream = parseBooleanFlag(next, true);
+                        i += 1;
+                    }
+                    else {
+                        agentStream = true;
+                    }
+                    break;
+                }
+                case "--max-epics":
+                    maxEpics = Number(argv[i + 1]);
+                    i += 1;
+                    break;
+                case "--max-stories-per-epic":
+                    maxStoriesPerEpic = Number(argv[i + 1]);
+                    i += 1;
+                    break;
+                case "--max-tasks-per-story":
+                    maxTasksPerStory = Number(argv[i + 1]);
+                    i += 1;
+                    break;
+                case "--quiet":
+                    quiet = true;
+                    break;
+                case "--help":
+                case "-h":
+                    // eslint-disable-next-line no-console
+                    console.log(usage);
+                    process.exit(0);
+                    break;
+                default:
+                    break;
+            }
+        }
+        else {
+            inputs.push(arg);
+        }
+    }
+    return {
+        workspaceRoot,
+        projectKey,
+        agentName,
+        agentStream: agentStream ?? true,
+        maxEpics: Number.isFinite(maxEpics) ? maxEpics : undefined,
+        maxStoriesPerEpic: Number.isFinite(maxStoriesPerEpic) ? maxStoriesPerEpic : undefined,
+        maxTasksPerStory: Number.isFinite(maxTasksPerStory) ? maxTasksPerStory : undefined,
+        quiet,
+        inputs,
+    };
+};
+export class CreateTasksCommand {
+    static async run(argv) {
+        const parsed = parseCreateTasksArgs(argv);
+        const workspace = await WorkspaceResolver.resolveWorkspace({
+            cwd: process.cwd(),
+            explicitWorkspace: parsed.workspaceRoot,
+        });
+        const derivedKey = path.basename(workspace.workspaceRoot).replace(/[^a-z0-9]+/gi, "").toLowerCase();
+        const projectKey = parsed.projectKey ?? (derivedKey || "proj");
+        const service = await CreateTasksService.create(workspace);
+        try {
+            const result = await service.createTasks({
+                workspace,
+                projectKey,
+                inputs: parsed.inputs,
+                agentName: parsed.agentName,
+                agentStream: parsed.agentStream,
+                maxEpics: parsed.maxEpics,
+                maxStoriesPerEpic: parsed.maxStoriesPerEpic,
+                maxTasksPerStory: parsed.maxTasksPerStory,
+            });
+            const dbPath = PathHelper.getWorkspaceDbPath(workspace.workspaceRoot);
+            if (!parsed.quiet) {
+                // eslint-disable-next-line no-console
+                console.log([
+                    `Created ${result.epics.length} epics, ${result.stories.length} stories, ${result.tasks.length} tasks, ${result.dependencies.length} dependencies.`,
+                    `Stored in ${dbPath}.`,
+                    `Job ID: ${result.jobId}, Command Run: ${result.commandRunId}`,
+                ].join("\n"));
+            }
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error(`create-tasks failed: ${error.message}`);
+            process.exitCode = 1;
+        }
+        finally {
+            await service.close();
+        }
+    }
+}

package/dist/commands/planning/MigrateTasksCommand.d.ts

@@ -0,0 +1,15 @@
+export interface ParsedMigrateTasksArgs {
+    workspaceRoot?: string;
+    projectKey?: string;
+    planDir?: string;
+    refinePlans: string[];
+    refinePlansDir?: string;
+    force: boolean;
+    quiet: boolean;
+    help: boolean;
+}
+export declare const parseMigrateTasksArgs: (argv: string[]) => ParsedMigrateTasksArgs;
+export declare class MigrateTasksCommand {
+    static run(argv: string[]): Promise<void>;
+}
+//# sourceMappingURL=MigrateTasksCommand.d.ts.map

package/dist/commands/planning/MigrateTasksCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrateTasksCommand.d.ts","sourceRoot":"","sources":["../../../src/commands/planning/MigrateTasksCommand.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf;AAED,eAAO,MAAM,qBAAqB,GAAI,MAAM,MAAM,EAAE,KAAG,sBA4BtD,CAAC;AAEF,qBAAa,mBAAmB;WACjB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAyDhD"}

package/dist/commands/planning/MigrateTasksCommand.js

@@ -0,0 +1,95 @@
+import path from "node:path";
+import { CreateTasksService, WorkspaceResolver } from "@mcoda/core";
+const usage = `mcoda migrate-tasks [--workspace-root <path>] [--project-key <key>] [--plan-dir <path>] [--refine-plan <path>] [--refine-plans-dir <path>] [--quiet]`;
+export const parseMigrateTasksArgs = (argv) => {
+    const args = {
+        refinePlans: [],
+        force: false,
+        quiet: false,
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--workspace-root" && argv[i + 1]) {
+            args.workspaceRoot = argv[++i];
+        }
+        else if ((arg === "--project" || arg === "--project-key") && argv[i + 1]) {
+            args.projectKey = argv[++i];
+        }
+        else if (arg === "--plan-dir" && argv[i + 1]) {
+            args.planDir = argv[++i];
+        }
+        else if (arg === "--refine-plan" && argv[i + 1]) {
+            args.refinePlans.push(argv[++i]);
+        }
+        else if (arg === "--refine-plans-dir" && argv[i + 1]) {
+            args.refinePlansDir = argv[++i];
+        }
+        else if (arg === "--force") {
+            args.force = true;
+        }
+        else if (arg === "--quiet") {
+            args.quiet = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            args.help = true;
+        }
+    }
+    return args;
+};
+export class MigrateTasksCommand {
+    static async run(argv) {
+        const args = parseMigrateTasksArgs(argv);
+        if (args.help) {
+            console.log(usage);
+            return;
+        }
+        const workspace = await WorkspaceResolver.resolveWorkspace({
+            cwd: process.cwd(),
+            explicitWorkspace: args.workspaceRoot ?? undefined,
+        });
+        const workspaceRoot = workspace.workspaceRoot;
+        const derivedKey = path.basename(workspaceRoot).replace(/[^a-z0-9]+/gi, "").toLowerCase();
+        const projectKey = args.projectKey ?? (derivedKey || "proj");
+        const planDir = args.planDir;
+        if (!projectKey) {
+            console.error("Project key is required. Use --project-key <key>.");
+            process.exitCode = 1;
+            return;
+        }
+        const service = await CreateTasksService.create(workspace);
+        try {
+            const result = await service.migratePlanFromFolder({
+                projectKey,
+                planDir,
+                force: args.force,
+                refinePlanPaths: args.refinePlans.length ? args.refinePlans : undefined,
+                refinePlansDir: args.refinePlansDir,
+            });
+            if (!args.quiet) {
+                console.log([
+                    `Migrated plan from ${planDir ?? path.join(workspaceRoot, ".mcoda", "tasks", projectKey)}`,
+                    `Epics: ${result.epics.length}`,
+                    `Stories: ${result.stories.length}`,
+                    `Tasks: ${result.tasks.length}`,
+                    `Dependencies: ${result.dependencies.length}`,
+                ].join("\n"));
+            }
+        }
+        catch (error) {
+            console.error(`migrate-tasks failed: ${error.message}`);
+            process.exitCode = 1;
+        }
+        finally {
+            try {
+                await service.close();
+            }
+            catch (error) {
+                const msg = error.message ?? "";
+                if (!msg.includes("database is closed")) {
+                    throw error;
+                }
+            }
+        }
+    }
+}

package/dist/commands/planning/PlanningCommands.d.ts

@@ -0,0 +1,3 @@
+export declare class PlanningCommands {
+}
+//# sourceMappingURL=PlanningCommands.d.ts.map

package/dist/commands/planning/PlanningCommands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlanningCommands.d.ts","sourceRoot":"","sources":["../../../src/commands/planning/PlanningCommands.ts"],"names":[],"mappings":"AAAA,qBAAa,gBAAgB;CAAG"}

package/dist/commands/planning/PlanningCommands.js

@@ -0,0 +1,2 @@
+export class PlanningCommands {
+}

package/dist/commands/planning/QaTasksCommand.d.ts

@@ -0,0 +1,30 @@
+interface ParsedArgs {
+    workspaceRoot?: string;
+    projectKey?: string;
+    taskKeys: string[];
+    epicKey?: string;
+    storyKey?: string;
+    statusFilter: string[];
+    mode: "auto" | "manual";
+    profileName?: string;
+    level?: string;
+    testCommand?: string;
+    agentName?: string;
+    agentStream: boolean;
+    createFollowupTasks: "auto" | "none" | "prompt";
+    dryRun: boolean;
+    json: boolean;
+    debug: boolean;
+    noTelemetry: boolean;
+    resumeJobId?: string;
+    result?: "pass" | "fail" | "blocked";
+    notes?: string;
+    evidenceUrl?: string;
+    quiet?: boolean;
+}
+export declare const parseQaTasksArgs: (argv: string[]) => ParsedArgs;
+export declare class QaTasksCommand {
+    static run(argv: string[]): Promise<void>;
+}
+export {};
+//# sourceMappingURL=QaTasksCommand.d.ts.map

package/dist/commands/planning/QaTasksCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QaTasksCommand.d.ts","sourceRoot":"","sources":["../../../src/commands/planning/QaTasksCommand.ts"],"names":[],"mappings":"AAIA,UAAU,UAAU;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,mBAAmB,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;IAChD,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAYD,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,EAAE,KAAG,UA4JjD,CAAC;AAEF,qBAAa,cAAc;WACZ,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAyHhD"}