mcoda 0.1.2 → 0.1.4

package/packages/cli/src/commands/work/WorkOnTasksCommand.ts

@@ -1,264 +0,0 @@
-import path from "node:path";
-import { WorkOnTasksService, WorkspaceResolver } from "@mcoda/core";
-
-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;
-}
-
-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: string | undefined, defaultValue: boolean): boolean => {
-  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: string | undefined): string[] => {
-  if (!value) return [];
-  return value
-    .split(",")
-    .map((v) => v.trim())
-    .filter(Boolean);
-};
-
-export const parseWorkOnTasksArgs = (argv: string[]): ParsedArgs => {
-  let workspaceRoot: string | undefined;
-  let projectKey: string | undefined;
-  let epicKey: string | undefined;
-  let storyKey: string | undefined;
-  const taskKeys: string[] = [];
-  const statusFilter: string[] = [];
-  let limit: number | undefined;
-  let parallel: number | undefined;
-  let noCommit = false;
-  let dryRun = false;
-  let agentName: string | undefined;
-  let agentStream: boolean | undefined;
-  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: string[]): Promise<void> {
-    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: string) => {
-        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/packages/cli/src/commands/workspace/SetWorkspaceCommand.ts

@@ -1,132 +0,0 @@
-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: string[]): { workspaceRoot?: string; git: boolean; docdex: boolean } => {
-  let workspaceRoot: string | undefined;
-  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: string): Promise<void> => {
-  const configPath = path.join(mcodaDir, "config.json");
-  try {
-    await fs.access(configPath);
-  } catch {
-    await fs.writeFile(configPath, "{}", "utf8");
-  }
-};
-
-const ensureDocsDirs = async (mcodaDir: string): Promise<void> => {
-  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: string): Promise<boolean> => {
-  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: string): Promise<boolean> => {
-  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: string): Promise<boolean> => {
-  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: string[]): Promise<void> {
-    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/packages/cli/test/packaging_guardrails.test.js

@@ -1,75 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const cwd = path.resolve(__dirname, "..");
-
-const normalizePath = (value) => value.replace(/\\/g, "/");
-
-const bannedMatchers = [
-  { pattern: /(^|\/)node_modules\//, reason: "node_modules" },
-  { pattern: /(^|\/)\.mcoda(\/|$)/, reason: "mcoda workspace state" },
-  { pattern: /(^|\/)\.docdex(\/|$)/, reason: "docdex state" },
-  { pattern: /(^|\/)dist\/__tests__\//, reason: "compiled tests" },
-  { pattern: /\.test\.[cm]?js$/i, reason: "test artifacts" },
-];
-
-const requiredPaths = [
-  "package.json",
-  "README.md",
-  "CHANGELOG.md",
-  "LICENSE",
-  "dist/bin/McodaEntrypoint.js",
-];
-
-const getPackList = () => {
-  const stdout = execFileSync("npm", ["pack", "--dry-run", "--json", "--ignore-scripts"], {
-    cwd,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-  let parsed;
-  try {
-    parsed = JSON.parse(stdout);
-  } catch (err) {
-    throw new Error(`npm pack --dry-run --json did not return JSON: ${err.message}\n${stdout}`);
-  }
-
-  const entries = Array.isArray(parsed) ? parsed : [parsed];
-  return entries
-    .flatMap((entry) => (entry.files || []).map((file) => (typeof file === "string" ? file : file.path)))
-    .filter(Boolean)
-    .map(normalizePath);
-};
-
-test("npm tarball has expected files and excludes unwanted artifacts", () => {
-  const files = getPackList();
-  const offenders = [];
-
-  for (const file of files) {
-    for (const { pattern, reason } of bannedMatchers) {
-      if (pattern.test(file)) {
-        offenders.push(`${file} (${reason})`);
-        break;
-      }
-    }
-  }
-
-  const missing = requiredPaths.filter((req) => !files.includes(req));
-
-  assert.equal(
-    offenders.length,
-    0,
-    `Packaging guardrails violated. Remove unexpected files:\n${offenders.join("\n")}`,
-  );
-  assert.equal(
-    missing.length,
-    0,
-    `Packaging guardrails violated. Required files missing:\n${missing.join("\n")}`,
-  );
-});

package/packages/cli/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist",
-    "declaration": true,
-    "declarationMap": true,
-    "paths": {
-      "@mcoda/shared": ["packages/shared/dist/index.d.ts"],
-      "@mcoda/shared/*": ["packages/shared/dist/*"],
-      "@mcoda/core": ["packages/core/dist/index.d.ts"],
-      "@mcoda/core/*": ["packages/core/dist/*"],
-      "@mcoda/db": ["packages/db/dist/index.d.ts"],
-      "@mcoda/db/*": ["packages/db/dist/*"],
-      "@mcoda/integrations": ["packages/integrations/dist/index.d.ts"],
-      "@mcoda/integrations/*": ["packages/integrations/dist/*"]
-    }
-  },
-  "include": ["src"]
-}

package/packages/core/CHANGELOG.md

@@ -1,7 +0,0 @@
-# Changelog
-
-## Unreleased
-- Initial public packaging for @mcoda/core.
-
-## 0.1.2
-- Initial release.

package/packages/core/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 bekir dag
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/packages/core/README.md

@@ -1,9 +0,0 @@
-# @mcoda/core
-
-Core services and APIs used by the mcoda CLI.
-
-## Usage
-This package is primarily an internal dependency of `mcoda`.
-
-## License
-MIT - see `LICENSE`.

package/packages/core/package.json

@@ -1,45 +0,0 @@
-{
-  "name": "@mcoda/core",
-  "version": "0.1.2",
-  "description": "Core services and APIs for the mcoda CLI.",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "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"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/bekirdag/mcoda.git"
-  },
-  "bugs": {
-    "url": "https://github.com/bekirdag/mcoda/issues"
-  },
-  "homepage": "https://github.com/bekirdag/mcoda#readme",
-  "license": "MIT",
-  "author": "bekir dag",
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@apidevtools/swagger-parser": "^10.1.0",
-    "@mcoda/shared": "workspace:*",
-    "@mcoda/db": "workspace:*",
-    "@mcoda/agents": "workspace:*",
-    "@mcoda/integrations": "workspace:*",
-    "yaml": "^2.4.2"
-  }
-}

package/packages/core/src/__tests__/SmokeClasses.test.ts

@@ -1,32 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { ExecutionService } from "../services/execution/ExecutionService.js";
-import { PlanningService } from "../services/planning/PlanningService.js";
-import { AgentManagementService } from "../services/agents/AgentManagementService.js";
-import { ConfigService } from "../config/ConfigService.js";
-import { Task } from "../domain/tasks/Task.js";
-import { Epic } from "../domain/epics/Epic.js";
-import { Project } from "../domain/projects/Project.js";
-import { UserStory } from "../domain/userStories/UserStory.js";
-import { Dependency } from "../domain/dependencies/Dependency.js";
-
-describe("core placeholder classes", () => {
-  it("constructs service shells", () => {
-    assert.equal(typeof ExecutionService, "function");
-    assert.equal(typeof PlanningService, "function");
-    assert.equal(typeof AgentManagementService, "function");
-    assert.equal(typeof ConfigService, "function");
-    assert.ok(new ExecutionService());
-    assert.ok(new PlanningService());
-    assert.ok(new AgentManagementService());
-    assert.ok(new ConfigService());
-  });
-
-  it("constructs domain shells", () => {
-    assert.ok(new Task());
-    assert.ok(new Epic());
-    assert.ok(new Project());
-    assert.ok(new UserStory());
-    assert.ok(new Dependency());
-  });
-});