mcoda 0.1.0

package/release-please-config.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+  "include-v-in-tag": true,
+  "include-component-in-tag": false,
+  "pull-request-title-pattern": "chore: release ${version}",
+  "linked-versions": true,
+  "packages": {
+    "packages/cli": {
+      "component": "mcoda",
+      "changelog-path": "packages/cli/CHANGELOG.md",
+      "release-type": "node"
+    },
+    "packages/core": {
+      "component": "@mcoda/core",
+      "changelog-path": "packages/core/CHANGELOG.md",
+      "release-type": "node"
+    },
+    "packages/shared": {
+      "component": "@mcoda/shared",
+      "changelog-path": "packages/shared/CHANGELOG.md",
+      "release-type": "node"
+    },
+    "packages/db": {
+      "component": "@mcoda/db",
+      "changelog-path": "packages/db/CHANGELOG.md",
+      "release-type": "node"
+    },
+    "packages/integrations": {
+      "component": "@mcoda/integrations",
+      "changelog-path": "packages/integrations/CHANGELOG.md",
+      "release-type": "node"
+    },
+    "packages/agents": {
+      "component": "@mcoda/agents",
+      "changelog-path": "packages/agents/CHANGELOG.md",
+      "release-type": "node"
+    }
+  }
+}

package/scripts/build-all.ts

@@ -0,0 +1 @@
+export class BuildAll {}

package/scripts/dev.ts

@@ -0,0 +1 @@
+export class Dev {}

package/scripts/install-local-cli.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Build the workspace and link the mcoda CLI globally for local development.
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+PNPM_BIN="${PNPM_BIN:-pnpm}"
+
+if ! command -v "${PNPM_BIN}" >/dev/null 2>&1; then
+  echo "pnpm not found. Install it with 'npm install -g pnpm' or point PNPM_BIN to your pnpm binary." >&2
+  exit 1
+fi
+
+echo "Installing workspace dependencies..."
+"${PNPM_BIN}" -C "${ROOT}" install
+
+echo "Building all packages (includes CLI dependencies)..."
+"${PNPM_BIN}" -C "${ROOT}" -r run build
+
+echo "Linking mcoda CLI globally..."
+"${PNPM_BIN}" -C "${ROOT}/packages/cli" link --global
+
+GLOBAL_BIN_DIR="$("${PNPM_BIN}" root -g)/.bin"
+
+echo
+echo "mcoda is now linked globally via pnpm."
+echo "Add to PATH if needed: export PATH=\"${GLOBAL_BIN_DIR}:\$PATH\""
+echo "Verify: ${GLOBAL_BIN_DIR}/mcoda --version"

package/scripts/pack-npm-tarballs.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+
+const root = process.cwd();
+const dest = path.join(root, "artifacts");
+const packages = [
+  "packages/cli",
+  "packages/core",
+  "packages/shared",
+  "packages/db",
+  "packages/integrations",
+  "packages/agents",
+];
+
+mkdirSync(dest, { recursive: true });
+
+const npmCommand = resolveNpmCommand();
+const npmArgs = ["pack", "--pack-destination", dest, "--ignore-scripts"];
+
+for (const pkg of packages) {
+  execFileSync(npmCommand.bin, npmCommand.prefixArgs.concat(npmArgs), {
+    cwd: path.join(root, pkg),
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      npm_config_ignore_scripts: "true",
+    },
+  });
+}
+
+function resolveNpmCommand() {
+  const candidates =
+    process.platform === "win32" ? ["npm.cmd", "npm.exe", "npm"] : ["npm"];
+
+  for (const candidate of candidates) {
+    try {
+      execFileSync(candidate, ["--version"], { stdio: "ignore" });
+      return { bin: candidate, prefixArgs: [] };
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        continue;
+      }
+    }
+  }
+
+  const npmCliPath = path.join(
+    path.dirname(process.execPath),
+    "node_modules",
+    "npm",
+    "bin",
+    "npm-cli.js"
+  );
+
+  if (existsSync(npmCliPath)) {
+    return { bin: process.execPath, prefixArgs: [npmCliPath] };
+  }
+
+  throw new Error(
+    "npm not found on PATH and npm-cli.js is missing from the Node installation."
+  );
+}

package/scripts/release.ts

@@ -0,0 +1 @@
+export class Release {}

package/scripts/run-node-tests.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+
+const roots = process.argv.slice(2).length ? process.argv.slice(2) : ["dist"];
+const testFiles = [];
+
+const collectTests = (target) => {
+  if (!existsSync(target)) return;
+  const stat = statSync(target);
+  if (stat.isDirectory()) {
+    const entries = readdirSync(target);
+    for (const entry of entries) {
+      collectTests(path.join(target, entry));
+    }
+    return;
+  }
+  if (target.endsWith(".test.js")) {
+    testFiles.push(target);
+  }
+};
+
+for (const root of roots) {
+  collectTests(path.resolve(process.cwd(), root));
+}
+
+if (!testFiles.length) {
+  console.log("No test files found; skipping.");
+  process.exit(0);
+}
+
+const result = spawnSync(process.execPath, ["--test", ...testFiles], {
+  stdio: "inherit",
+});
+
+process.exit(result.status ?? 1);

package/tests/all.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { mkdirSync, writeFileSync, readdirSync, statSync, existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+const run = (label, cmd, args, options = {}) => {
+  const start = Date.now();
+  const result = spawnSync(cmd, args, {
+    cwd: root,
+    stdio: "inherit",
+    env: process.env,
+    ...options,
+  });
+  const durationMs = Date.now() - start;
+  const status = typeof result.status === "number" ? result.status : 1;
+  return {
+    label,
+    cmd: [cmd, ...args].join(" "),
+    status,
+    durationMs,
+    error: result.error ? String(result.error) : undefined,
+  };
+};
+
+const results = [];
+
+const resolvePnpm = () => {
+  if (process.env.PNPM_BIN) return process.env.PNPM_BIN;
+  const pnpmHome = process.env.PNPM_HOME;
+  if (pnpmHome) {
+    const candidate = path.join(pnpmHome, process.platform === "win32" ? "pnpm.cmd" : "pnpm");
+    if (existsSync(candidate)) return candidate;
+  }
+  return process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+};
+
+const pnpm = resolvePnpm();
+let failed = false;
+
+const collectTests = (dir) => {
+  const entries = readdirSync(dir);
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      if (entry === "results") continue;
+      files.push(...collectTests(fullPath));
+    } else if (entry.endsWith(".test.js")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+};
+
+if (process.env.MCODA_SKIP_WORKSPACE_TESTS !== "1") {
+  const shell = process.platform === "win32";
+  if (process.platform === "win32") {
+    const workspacePackages = [
+      "packages/shared",
+      "packages/generators",
+      "packages/integrations",
+      "packages/db",
+      "packages/agents",
+      "packages/core",
+      "packages/cli",
+      "packages/testing",
+    ];
+    for (const pkg of workspacePackages) {
+      let workspace = run(`workspace-tests:${pkg}`, pnpm, ["--filter", pkg, "run", "test"], { shell });
+      if (workspace.error) {
+        const fallback = run(`workspace-tests-corepack:${pkg}`, "corepack", ["pnpm", "--filter", pkg, "run", "test"], {
+          shell,
+        });
+        results.push(workspace, fallback);
+        workspace = fallback;
+      } else {
+        results.push(workspace);
+      }
+      if (workspace.error) {
+        console.error(`[${workspace.label}] ${workspace.error}`);
+      }
+      if (workspace.status !== 0) failed = true;
+    }
+  } else {
+    let workspace = run("workspace-tests", pnpm, ["-r", "run", "test"], { shell });
+    if (workspace.error) {
+      const fallback = run("workspace-tests-corepack", "corepack", ["pnpm", "-r", "run", "test"], { shell });
+      results.push(workspace, fallback);
+      workspace = fallback;
+    } else {
+      results.push(workspace);
+    }
+    if (workspace.error) {
+      console.error(`[${workspace.label}] ${workspace.error}`);
+    }
+    if (workspace.status !== 0) failed = true;
+  }
+}
+
+const testFiles = collectTests(path.join(root, "tests")).map((file) => path.relative(root, file));
+const repoTests = run("repo-tests", process.execPath, ["--test", ...testFiles]);
+results.push(repoTests);
+if (repoTests.error) {
+  console.error(`[${repoTests.label}] ${repoTests.error}`);
+}
+if (repoTests.status !== 0) failed = true;
+
+const artifactsDir = path.join(root, "tests", "results");
+mkdirSync(artifactsDir, { recursive: true });
+writeFileSync(
+  path.join(artifactsDir, "test-summary.json"),
+  JSON.stringify(
+    {
+      timestamp: new Date().toISOString(),
+      results,
+    },
+    null,
+    2,
+  ) +
+    "\n",
+);
+
+process.exit(failed ? 1 : 0);

package/tests/api/openapi_spec.test.js

@@ -0,0 +1,21 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+test("OpenAPI spec includes core endpoints", async () => {
+  const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+  const specPath = path.join(root, "openapi", "mcoda.yaml");
+  const raw = await fs.readFile(specPath, "utf8");
+  const openapiLine = raw.split("\n").find((line) => line.startsWith("openapi:"));
+  assert.ok(openapiLine, "Missing openapi version line");
+  assert.ok(openapiLine?.includes("3."), "Expected OpenAPI 3.x version");
+
+  const requiredPaths = ["/agents", "/tasks/{id}", "/workspaces/{id}/backlog", "/system/ping"];
+  for (const entry of requiredPaths) {
+    const escaped = entry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`^\\s*${escaped}:`, "m");
+    assert.ok(pattern.test(raw), `Missing OpenAPI path: ${entry}`);
+  }
+});

package/tests/artifacts.md

@@ -0,0 +1,31 @@
+# Test Artifacts
+
+## Test runner
+- tests/all.js
+- tests/results/test-summary.json
+
+## Unit tests
+- tests/unit/path_helper.test.js
+- tests/unit/crypto_helper.test.js
+
+## Component tests
+- tests/component/cli_version.test.js
+
+## Integration tests
+- tests/integration/workspace_resolver.test.js
+
+## API tests
+- tests/api/openapi_spec.test.js
+
+## Workspace package tests
+- packages/agents/src/__tests__
+- packages/cli/src/__tests__
+- packages/core/src/**/__tests__
+- packages/db/src/__tests__
+- packages/generators/src/__tests__
+- packages/integrations/src/**/__tests__
+- packages/shared/src/__tests__
+- packages/testing/src/__tests__
+
+## Packaging guardrails
+- packages/cli/test/packaging_guardrails.test.js

package/tests/component/cli_version.test.js

@@ -0,0 +1,38 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import packageJson from "../../packages/cli/package.json" with { type: "json" };
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+const entrypointPath = path.join(root, "packages", "cli", "dist", "bin", "McodaEntrypoint.js");
+
+const fileExists = async (candidate) => {
+  try {
+    await fs.access(candidate);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+test("mcoda --version prints the CLI package version", async (t) => {
+  if (!(await fileExists(entrypointPath))) {
+    t.skip("CLI dist output not found; run pnpm -r run build first.");
+    return;
+  }
+
+  const { McodaEntrypoint } = await import(pathToFileURL(entrypointPath).href);
+  const logs = [];
+  const originalLog = console.log;
+  console.log = (...args) => logs.push(args.join(" "));
+
+  try {
+    await McodaEntrypoint.run(["--version"]);
+  } finally {
+    console.log = originalLog;
+  }
+
+  assert.equal(logs[0], packageJson.version);
+});

package/tests/integration/workspace_resolver.test.js

@@ -0,0 +1,44 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+const workspaceManagerPath = path.join(root, "packages", "core", "dist", "workspace", "WorkspaceManager.js");
+
+const fileExists = async (candidate) => {
+  try {
+    await fs.access(candidate);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+test("WorkspaceResolver initializes mcoda workspace state", async (t) => {
+  if (!(await fileExists(workspaceManagerPath))) {
+    t.skip("Core dist output not found; run pnpm -r run build first.");
+    return;
+  }
+
+  const { WorkspaceResolver } = await import(pathToFileURL(workspaceManagerPath).href);
+  const workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-workspace-"));
+
+  const resolved = await WorkspaceResolver.resolveWorkspace({
+    cwd: workspaceRoot,
+    explicitWorkspace: workspaceRoot,
+  });
+
+  assert.equal(resolved.workspaceRoot, workspaceRoot);
+  assert.equal(resolved.mcodaDir, path.join(workspaceRoot, ".mcoda"));
+  assert.equal(resolved.workspaceDbPath, path.join(workspaceRoot, ".mcoda", "mcoda.db"));
+
+  const workspaceJson = path.join(workspaceRoot, ".mcoda", "workspace.json");
+  const payload = JSON.parse(await fs.readFile(workspaceJson, "utf8"));
+  assert.match(payload.id, /^[a-f0-9-]{36}$/i);
+
+  const gitignore = await fs.readFile(path.join(workspaceRoot, ".gitignore"), "utf8");
+  assert.ok(gitignore.includes(".mcoda/"));
+});

package/tests/unit/crypto_helper.test.js

@@ -0,0 +1,36 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { CryptoHelper } from "../../packages/shared/src/crypto/CryptoHelper.js";
+
+test("CryptoHelper round-trips secrets with a generated key", async () => {
+  const originalHome = process.env.HOME;
+  const originalUserProfile = process.env.USERPROFILE;
+  const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-home-"));
+  process.env.HOME = tempHome;
+  process.env.USERPROFILE = tempHome;
+
+  try {
+    const secret = "mcoda-secret";
+    const encrypted = await CryptoHelper.encryptSecret(secret);
+    const decrypted = await CryptoHelper.decryptSecret(encrypted);
+    assert.equal(decrypted, secret);
+
+    const keyPath = path.join(tempHome, ".mcoda", "mcoda.key");
+    const key = await fs.readFile(keyPath);
+    assert.equal(key.length, 32);
+  } finally {
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    if (originalUserProfile === undefined) {
+      delete process.env.USERPROFILE;
+    } else {
+      process.env.USERPROFILE = originalUserProfile;
+    }
+  }
+});

package/tests/unit/path_helper.test.js

@@ -0,0 +1,20 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { PathHelper } from "../../packages/shared/src/paths/PathHelper.js";
+
+test("PathHelper workspace paths derive from cwd", () => {
+  const cwd = path.join(os.tmpdir(), "mcoda-path-helper");
+  assert.equal(PathHelper.getWorkspaceDir(cwd), path.join(cwd, ".mcoda"));
+  assert.equal(PathHelper.getWorkspaceDbPath(cwd), path.join(cwd, ".mcoda", "mcoda.db"));
+});
+
+test("PathHelper.ensureDir creates nested directories", async () => {
+  const base = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-paths-"));
+  const target = path.join(base, "a", "b", "c");
+  await PathHelper.ensureDir(target);
+  const stat = await fs.stat(target);
+  assert.equal(stat.isDirectory(), true);
+});

package/tsconfig.base.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "target": "ES2020",
+    "moduleResolution": "NodeNext",
+    "rootDir": ".",
+    "baseUrl": ".",
+    "paths": {
+      "@mcoda/shared": ["packages/shared/src/index.ts"],
+      "@mcoda/shared/*": ["packages/shared/src/*"],
+      "@mcoda/db": ["packages/db/src/index.ts"],
+      "@mcoda/db/*": ["packages/db/src/*"],
+      "@mcoda/agents": ["packages/agents/src/index.ts"],
+      "@mcoda/agents/*": ["packages/agents/src/*"],
+      "@mcoda/integrations": ["packages/integrations/src/index.ts"],
+      "@mcoda/integrations/*": ["packages/integrations/src/*"],
+      "@mcoda/core": ["packages/core/src/index.ts"],
+      "@mcoda/core/*": ["packages/core/src/*"],
+      "@mcoda/generators": ["packages/generators/src/index.ts"],
+      "@mcoda/generators/*": ["packages/generators/src/*"],
+      "@mcoda/cli": ["packages/cli/src/index.ts"],
+      "@mcoda/cli/*": ["packages/cli/src/*"],
+      "@mcoda/testing": ["packages/testing/src/index.ts"],
+      "@mcoda/testing/*": ["packages/testing/src/*"]
+    },
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  }
+}