mcoda 0.1.2 → 0.1.4

package/dist/commands/work/WorkOnTasksCommand.js

@@ -0,0 +1,238 @@
+import path from "node:path";
+import { WorkOnTasksService, WorkspaceResolver } from "@mcoda/core";
+const usage = `mcoda work-on-tasks \\
+  [--workspace <PATH>] \\
+  [--project <PROJECT_KEY>] \\
+  [--task <TASK_KEY> ... | --epic <EPIC_KEY> | --story <STORY_KEY>] \\
+  [--status not_started,in_progress] \\
+  [--limit N] \\
+  [--parallel N] \\
+  [--no-commit] \\
+  [--dry-run] \\
+  [--agent <NAME>] \\
+  [--agent-stream <true|false>] \\
+  [--json]`;
+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;
+};
+const parseCsv = (value) => {
+    if (!value)
+        return [];
+    return value
+        .split(",")
+        .map((v) => v.trim())
+        .filter(Boolean);
+};
+export const parseWorkOnTasksArgs = (argv) => {
+    let workspaceRoot;
+    let projectKey;
+    let epicKey;
+    let storyKey;
+    const taskKeys = [];
+    const statusFilter = [];
+    let limit;
+    let parallel;
+    let noCommit = false;
+    let dryRun = false;
+    let agentName;
+    let agentStream;
+    let json = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg.startsWith("--status=")) {
+            const [, raw] = arg.split("=", 2);
+            statusFilter.push(...parseCsv(raw));
+            continue;
+        }
+        if (arg.startsWith("--task=")) {
+            const [, raw] = arg.split("=", 2);
+            if (raw)
+                taskKeys.push(raw);
+            continue;
+        }
+        if (arg.startsWith("--agent-stream=")) {
+            const [, raw] = arg.split("=", 2);
+            agentStream = parseBooleanFlag(raw, true);
+            continue;
+        }
+        switch (arg) {
+            case "--workspace":
+            case "--workspace-root":
+                workspaceRoot = argv[i + 1] ? path.resolve(argv[i + 1]) : undefined;
+                i += 1;
+                break;
+            case "--project":
+            case "--project-key":
+                projectKey = argv[i + 1];
+                i += 1;
+                break;
+            case "--status":
+                statusFilter.push(...parseCsv(argv[i + 1]));
+                i += 1;
+                break;
+            case "--epic":
+                epicKey = argv[i + 1];
+                i += 1;
+                break;
+            case "--story":
+                storyKey = argv[i + 1];
+                i += 1;
+                break;
+            case "--task":
+                if (argv[i + 1]) {
+                    taskKeys.push(argv[i + 1]);
+                    i += 1;
+                }
+                break;
+            case "--limit":
+                limit = Number(argv[i + 1]);
+                i += 1;
+                break;
+            case "--parallel":
+                parallel = Number(argv[i + 1]);
+                i += 1;
+                break;
+            case "--no-commit":
+                noCommit = true;
+                break;
+            case "--dry-run":
+                dryRun = true;
+                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 "--json":
+                json = true;
+                break;
+            case "--help":
+            case "-h":
+                // eslint-disable-next-line no-console
+                console.log(usage);
+                process.exit(0);
+                break;
+            default:
+                break;
+        }
+    }
+    if (statusFilter.length === 0) {
+        statusFilter.push("not_started", "in_progress");
+    }
+    return {
+        workspaceRoot,
+        projectKey,
+        epicKey,
+        storyKey,
+        taskKeys,
+        statusFilter,
+        limit: Number.isFinite(limit) ? limit : undefined,
+        parallel: Number.isFinite(parallel) ? parallel : undefined,
+        noCommit,
+        dryRun,
+        agentName,
+        agentStream: agentStream ?? true,
+        json,
+    };
+};
+export class WorkOnTasksCommand {
+    static async run(argv) {
+        const parsed = parseWorkOnTasksArgs(argv);
+        const workspace = await WorkspaceResolver.resolveWorkspace({
+            cwd: process.cwd(),
+            explicitWorkspace: parsed.workspaceRoot,
+        });
+        if (!parsed.projectKey) {
+            // eslint-disable-next-line no-console
+            console.error("work-on-tasks requires --project <PROJECT_KEY>");
+            process.exitCode = 1;
+            return;
+        }
+        const service = await WorkOnTasksService.create(workspace);
+        try {
+            const streamSink = (chunk) => {
+                const target = parsed.json ? process.stderr : process.stdout;
+                target.write(chunk);
+            };
+            const onAgentChunk = parsed.agentStream !== false ? streamSink : undefined;
+            const result = await service.workOnTasks({
+                workspace,
+                projectKey: parsed.projectKey,
+                epicKey: parsed.epicKey,
+                storyKey: parsed.storyKey,
+                taskKeys: parsed.taskKeys.length ? parsed.taskKeys : undefined,
+                statusFilter: parsed.statusFilter,
+                limit: parsed.limit,
+                parallel: parsed.parallel,
+                noCommit: parsed.noCommit,
+                dryRun: parsed.dryRun,
+                agentName: parsed.agentName,
+                agentStream: parsed.agentStream,
+                onAgentChunk,
+            });
+            const success = result.results.filter((r) => r.status === "succeeded").length;
+            const failed = result.results.filter((r) => r.status === "failed" || r.status === "blocked").length;
+            const skipped = result.results.filter((r) => r.status === "skipped").length;
+            const blockedKeys = [
+                ...result.selection.blocked.map((t) => t.task.key),
+                ...result.results.filter((r) => r.status === "blocked").map((r) => r.taskKey),
+            ];
+            if (failed > 0) {
+                process.exitCode = 1;
+            }
+            if (parsed.json) {
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify({
+                    jobId: result.jobId,
+                    commandRunId: result.commandRunId,
+                    processed: result.results.length,
+                    succeeded: success,
+                    failed,
+                    skipped,
+                    blocked: blockedKeys,
+                    warnings: result.warnings,
+                }, null, 2));
+                return;
+            }
+            const summary = [
+                `Job: ${result.jobId}, Command Run: ${result.commandRunId}`,
+                `Tasks processed: ${result.results.length} (succeeded=${success}, failed=${failed}, skipped=${skipped})`,
+                blockedKeys.length ? `Blocked: ${blockedKeys.join(", ")}` : undefined,
+            ]
+                .filter(Boolean)
+                .join("\n");
+            // eslint-disable-next-line no-console
+            console.log(summary);
+            if (result.warnings.length) {
+                // eslint-disable-next-line no-console
+                console.warn(result.warnings.map((w) => `! ${w}`).join("\n"));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.error(`work-on-tasks failed: ${message}`);
+            process.exitCode = 1;
+        }
+        finally {
+            await service.close();
+        }
+    }
+}

package/dist/commands/workspace/SetWorkspaceCommand.d.ts

@@ -0,0 +1,9 @@
+export declare const parseSetWorkspaceArgs: (argv: string[]) => {
+    workspaceRoot?: string;
+    git: boolean;
+    docdex: boolean;
+};
+export declare class SetWorkspaceCommand {
+    static run(argv: string[]): Promise<void>;
+}
+//# sourceMappingURL=SetWorkspaceCommand.d.ts.map

package/dist/commands/workspace/SetWorkspaceCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SetWorkspaceCommand.d.ts","sourceRoot":"","sources":["../../../src/commands/workspace/SetWorkspaceCommand.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB,GAAI,MAAM,MAAM,EAAE,KAAG;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAyB7G,CAAC;AA4DF,qBAAa,mBAAmB;WACjB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAqChD"}

package/dist/commands/workspace/SetWorkspaceCommand.js

@@ -0,0 +1,128 @@
+import { execSync } from "node:child_process";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { WorkspaceResolver } from "@mcoda/core";
+import { WorkspaceRepository } from "@mcoda/db";
+const USAGE = "Usage: mcoda set-workspace [--workspace-root <path>] [--no-git] [--no-docdex]";
+export const parseSetWorkspaceArgs = (argv) => {
+    let workspaceRoot;
+    let git = true;
+    let docdex = true;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        switch (arg) {
+            case "--workspace-root":
+                workspaceRoot = argv[i + 1];
+                i += 1;
+                break;
+            case "--no-git":
+                git = false;
+                break;
+            case "--no-docdex":
+                docdex = false;
+                break;
+            case "--help":
+            case "-h":
+                throw new Error(USAGE);
+            default:
+                break;
+        }
+    }
+    return { workspaceRoot, git, docdex };
+};
+const ensureConfigFile = async (mcodaDir) => {
+    const configPath = path.join(mcodaDir, "config.json");
+    try {
+        await fs.access(configPath);
+    }
+    catch {
+        await fs.writeFile(configPath, "{}", "utf8");
+    }
+};
+const ensureDocsDirs = async (mcodaDir) => {
+    await fs.mkdir(path.join(mcodaDir, "docs", "pdr"), { recursive: true });
+    await fs.mkdir(path.join(mcodaDir, "docs", "sds"), { recursive: true });
+    await fs.mkdir(path.join(mcodaDir, "jobs"), { recursive: true });
+};
+const ensureGitRepo = async (workspaceRoot) => {
+    try {
+        await fs.access(path.join(workspaceRoot, ".git"));
+        return false;
+    }
+    catch {
+        try {
+            execSync("git init", { cwd: workspaceRoot, stdio: "ignore" });
+            return true;
+        }
+        catch {
+            // ignore git init failures; user can init later
+            return false;
+        }
+    }
+};
+const ensureCodexTrust = async (workspaceRoot) => {
+    try {
+        execSync("codex --version", { stdio: "ignore" });
+    }
+    catch {
+        return false;
+    }
+    try {
+        execSync(`codex trust add "${workspaceRoot}"`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const ensureDocdexIndex = async (workspaceRoot) => {
+    try {
+        execSync("docdex --version", { stdio: "ignore" });
+    }
+    catch {
+        return false;
+    }
+    try {
+        execSync("docdex index", { cwd: workspaceRoot, stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export class SetWorkspaceCommand {
+    static async run(argv) {
+        const parsed = parseSetWorkspaceArgs(argv);
+        const resolution = await WorkspaceResolver.resolveWorkspace({
+            cwd: process.cwd(),
+            explicitWorkspace: parsed.workspaceRoot,
+        });
+        await ensureConfigFile(resolution.mcodaDir);
+        await ensureDocsDirs(resolution.mcodaDir);
+        await (await WorkspaceRepository.create(resolution.workspaceRoot)).close();
+        let gitInited = false;
+        if (parsed.git) {
+            gitInited = await ensureGitRepo(resolution.workspaceRoot);
+        }
+        const codexTrusted = await ensureCodexTrust(resolution.workspaceRoot);
+        const docdexIndexed = parsed.docdex ? await ensureDocdexIndex(resolution.workspaceRoot) : false;
+        // eslint-disable-next-line no-console
+        console.log(`Workspace ready at ${resolution.workspaceRoot}`);
+        if (gitInited) {
+            // eslint-disable-next-line no-console
+            console.log("Initialized new git repository.");
+        }
+        if (codexTrusted) {
+            // eslint-disable-next-line no-console
+            console.log("Granted codex CLI trust for this workspace.");
+        }
+        if (docdexIndexed) {
+            // eslint-disable-next-line no-console
+            console.log("Docdex index initialized for this workspace.");
+        }
+        // eslint-disable-next-line no-console
+        console.log(`.mcoda directory: ${resolution.mcodaDir}`);
+        // eslint-disable-next-line no-console
+        console.log("You can now run mcoda commands here.");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./commands/agents/AgentsCommands.js";
+export * from "./bin/McodaEntrypoint.js";
+export * from "./commands/docs/DocsCommands.js";
+export * from "./commands/jobs/JobsCommands.js";
+export * from "./commands/openapi/OpenapiCommands.js";
+export * from "./commands/planning/CreateTasksCommand.js";
+export * from "./commands/backlog/BacklogCommands.js";
+export * from "./commands/backlog/TaskShowCommands.js";
+export * from "./commands/backlog/OrderTasksCommand.js";
+export * from "./commands/estimate/EstimateCommands.js";
+export * from "./commands/telemetry/TelemetryCommands.js";
+export * from "./commands/planning/RefineTasksCommand.js";
+export * from "./commands/work/WorkOnTasksCommand.js";
+export * from "./commands/review/CodeReviewCommand.js";
+export * from "./commands/planning/QaTasksCommand.js";
+export * from "./commands/update/UpdateCommands.js";
+export * from "./commands/routing/RoutingCommands.js";
+export * from "./commands/agents/TestAgentCommand.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,uCAAuC,CAAC;AACtD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,yCAAyC,CAAC;AACxD,cAAc,yCAAyC,CAAC;AACxD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,uCAAuC,CAAC;AACtD,cAAc,qCAAqC,CAAC;AACpD,cAAc,uCAAuC,CAAC;AACtD,cAAc,uCAAuC,CAAC"}

package/package.json

@@ -1,9 +1,27 @@
 {
   "name": "mcoda",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Local-first CLI for planning, documentation, and execution workflows with agent assistance.",
-  "private": false,
   "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "mcoda": "dist/bin/McodaEntrypoint.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/__tests__/**",
+    "!dist/**/*.test.*",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "echo \"lint not configured\"",
+    "test": "pnpm run build && node ../../scripts/run-node-tests.js dist",
+    "pack:verify": "node --test test/packaging_guardrails.test.js"
+  },
   "engines": {
     "node": ">=20"
   },
@@ -28,19 +46,16 @@
     "pdr",
     "sds"
   ],
-  "workspaces": [
-    "packages/*"
-  ],
-  "devDependencies": {
-    "@types/node": "^20.11.30",
-    "eslint": "^8.57.0",
-    "prettier": "^3.2.5",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.4.0"
+  "publishConfig": {
+    "access": "public"
   },
-  "scripts": {
-    "build": "pnpm -r run build",
-    "lint": "pnpm -r run lint",
-    "test": "pnpm -r run test"
+  "dependencies": {
+    "@mcoda/core": "workspace:*",
+    "@mcoda/shared": "workspace:*",
+    "yaml": "^2.4.2"
+  },
+  "devDependencies": {
+    "@mcoda/db": "workspace:*",
+    "@mcoda/integrations": "workspace:*"
   }
-}
+}

package/.editorconfig

@@ -1,9 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-insert_final_newline = true
-indent_style = space
-indent_size = 2
-trim_trailing_whitespace = true

package/.eslintrc.cjs

@@ -1,12 +0,0 @@
-module.exports = {
-  root: true,
-  env: {
-    node: true,
-    es2020: true
-  },
-  parserOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module'
-  },
-  ignorePatterns: ['dist', 'node_modules']
-};

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,29 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: "[Bug] "
-labels: bug
-assignees: ''
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. ...
-2. ...
-
-**Expected behavior**
-What you expected to happen.
-
-**Logs / output**
-Paste relevant logs/CLI output (redact secrets). Use code fences.
-
-**Environment**
-- OS/arch:
-- Node version:
-- mcoda version:
-
-**Additional context**
-Add any other context or screenshots about the problem here.

package/.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: Security issues
-    url: https://github.com/bekirdag/mcoda/security/advisories
-    about: Please report security vulnerabilities privately.

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,19 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for mcoda
-title: "[Feature] "
-labels: enhancement
-assignees: ''
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear description of the problem.
-
-**Describe the solution you'd like**
-What should mcoda do?
-
-**Describe alternatives you've considered**
-Other approaches or workarounds.
-
-**Additional context**
-Anything else we should know.

package/.github/workflows/ci.yml

@@ -1,37 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-      - master
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - name: Install deps
-        run: pnpm install
-
-      - name: Build
-        run: pnpm -r run build
-
-      - name: Run tests
-        run: node tests/all.js
-
-      - name: Packaging guardrails
-        run: pnpm --filter mcoda run pack:verify

package/.github/workflows/nightly.yml

@@ -1,38 +0,0 @@
-name: Nightly Quality
-
-on:
-  schedule:
-    - cron: "0 3 * * *"
-  workflow_dispatch:
-
-jobs:
-  quality:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - name: Install deps
-        run: pnpm install
-
-      - name: Build
-        run: pnpm -r run build
-
-      - name: Run tests
-        run: node tests/all.js
-
-      - name: Packaging guardrails
-        run: pnpm --filter mcoda run pack:verify
-
-      - name: Security audit
-        run: pnpm audit --audit-level high

package/.github/workflows/release-dry-run.yml

@@ -1,40 +0,0 @@
-name: Release Dry Run
-
-on:
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  dry-run:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org
-
-      - name: Install deps
-        run: pnpm install
-
-      - name: Build
-        run: pnpm -r run build
-
-      - name: Run tests
-        run: node tests/all.js
-
-      - name: Packaging guardrails
-        run: pnpm --filter mcoda run pack:verify
-
-      - name: npm publish dry run
-        run: pnpm -r publish --dry-run --access public --no-git-checks

package/.github/workflows/release-please.yml

@@ -1,22 +0,0 @@
-name: Release Please
-
-on:
-  push:
-    branches:
-      - main
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  release-please:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Run release-please
-        uses: googleapis/release-please-action@v4
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          config-file: release-please-config.json
-          manifest-file: .release-please-manifest.json