xcoder-dna 0.0.0-stage → 1.3.0

package/dist/commands/test.js

@@ -0,0 +1,385 @@
+import { spawn } from "node:child_process";
+import { readdirSync, existsSync } from "node:fs";
+import path from "node:path";
+import { log } from "../util/logger.js";
+import { createSpinner } from "../util/spinner.js";
+import { trackPid, untrackPid } from "../util/process-kill.js";
+// ── Predefined suites ──
+const PREDEFINED_SUITES = [
+    {
+        name: "unit",
+        configPath: "vitest.config.ts",
+        npmScript: "npm test",
+        label: "Unit Tests",
+    },
+    {
+        name: "e2e",
+        configPath: "e2e/vitest.config.ts",
+        npmScript: "npm run test:e2e",
+        label: "E2E Tests",
+    },
+];
+// ── Per-folder suite discovery ──
+/**
+ * Scan src/ directories for *.test.ts files, group by immediate parent
+ * directory, and produce one suite descriptor per folder that has tests.
+ * Skips folders with no tests. Uses the share vitest config, scoped
+ * via --include.
+ */
+export function generateFolderSuites(rootDir) {
+    const srcDir = path.join(rootDir, "src");
+    if (!existsSync(srcDir))
+        return [];
+    const folderMap = new Map();
+    function walk(dir) {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".test.ts")) {
+                // Determine the top-level folder under src/
+                const rel = path.relative(srcDir, full);
+                const topFolder = rel.split(path.sep)[0] || "root";
+                if (!folderMap.has(topFolder)) {
+                    folderMap.set(topFolder, []);
+                }
+                folderMap.get(topFolder).push(rel);
+            }
+        }
+    }
+    walk(srcDir);
+    // Build suite descriptors sorted by folder name.
+    const suites = [];
+    for (const [folder, files] of [...folderMap.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+        // Build absolute paths from the src-relative file list.
+        const filePaths = files.map((f) => path.join("src", f));
+        suites.push({
+            name: `folder:${folder}`,
+            configPath: "vitest.config.ts",
+            npmScript: `npx vitest run --config vitest.config.ts ${filePaths.map((f) => `"${f}"`).join(" ")}`,
+            label: `src/${folder}`,
+            testFiles: filePaths,
+        });
+    }
+    return suites;
+}
+// ── Suite runner ──
+/**
+ * Spawn vitest as a child process for a single suite, capture
+ * stdout/stderr, enforce a per-suite timeout, and return a
+ * structured SuiteResult.
+ *
+ * Uses vitest's built-in JSON reporter so we can parse test counts
+ * for the summary. Falls back to exit-code-only pass/fail if JSON
+ * parsing fails (vitest crash, old version, etc.).
+ *
+ * If suite has testFiles, they are passed as positional arguments.
+ */
+export function runSuite(suite, timeoutMs, capture) {
+    return new Promise((resolve) => {
+        const start = Date.now();
+        // We always use --reporter=json so we can parse counts, but if
+        // the user wants live output we let stdout through _in addition_.
+        const args = [
+            "vitest",
+            "run",
+            "--config",
+            suite.configPath,
+            "--reporter=json",
+        ];
+        // Add test file paths as positional arguments (vitest filter).
+        // Avoid globs — they don't expand on Windows with shell:true.
+        if (suite.testFiles && suite.testFiles.length > 0) {
+            for (const f of suite.testFiles) {
+                args.push(f);
+            }
+        }
+        const child = spawn("npx", args, {
+            cwd: process.cwd(),
+            shell: process.platform === "win32",
+            stdio: capture ? "pipe" : ["pipe", "inherit", "pipe"],
+        });
+        // Track PID for cleanup on interrupt.
+        if (child.pid) {
+            trackPid(child.pid);
+        }
+        let stdout = "";
+        let stderr = "";
+        if (child.stdout) {
+            child.stdout.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                stdout += chunk;
+            });
+        }
+        if (child.stderr) {
+            child.stderr.setEncoding("utf8");
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk;
+            });
+        }
+        const timeout = setTimeout(() => {
+            if (child.pid)
+                untrackPid(child.pid);
+            child.kill("SIGKILL");
+            resolve({
+                suiteName: suite.name,
+                passed: false,
+                durationMs: Date.now() - start,
+                testCount: null,
+                passedCount: null,
+                failedCount: null,
+                exitCode: null,
+                error: `Suite timed out after ${timeoutMs}ms`,
+            });
+        }, timeoutMs);
+        child.on("close", (code) => {
+            clearTimeout(timeout);
+            if (child.pid)
+                untrackPid(child.pid);
+            const durationMs = Date.now() - start;
+            // Try to parse JSON reporter output for test counts.
+            let testCount = null;
+            let passedCount = null;
+            let failedCount = null;
+            try {
+                // vitest JSON reporter outputs one JSON object per test file on stdout.
+                // The last line should be a summary object with `numTotalTests` etc.
+                const lines = stdout.trim().split("\n");
+                for (let i = lines.length - 1; i >= 0; i--) {
+                    const line = lines[i].trim();
+                    if (!line)
+                        continue;
+                    try {
+                        const parsed = JSON.parse(line);
+                        if (parsed && typeof parsed.numTotalTests === "number") {
+                            testCount = parsed.numTotalTests;
+                            passedCount = parsed.numPassedTests ?? null;
+                            failedCount = parsed.numFailedTests ?? null;
+                            break;
+                        }
+                    }
+                    catch {
+                        // Not valid JSON — skip this line.
+                    }
+                }
+            }
+            catch {
+                // JSON parsing failed entirely — fall back to exit-code-only.
+            }
+            if (testCount === null && !capture) {
+                log.dim(`Warning: could not parse test counts from vitest JSON output for ${suite.name}`);
+            }
+            const passed = code === 0;
+            resolve({
+                suiteName: suite.name,
+                passed,
+                durationMs,
+                testCount,
+                passedCount,
+                failedCount,
+                exitCode: code,
+                error: code !== 0 && stderr ? stderr.slice(0, 500) : null,
+            });
+        });
+        child.on("error", (err) => {
+            clearTimeout(timeout);
+            if (child.pid)
+                untrackPid(child.pid);
+            resolve({
+                suiteName: suite.name,
+                passed: false,
+                durationMs: Date.now() - start,
+                testCount: null,
+                passedCount: null,
+                failedCount: null,
+                exitCode: null,
+                error: err.message,
+            });
+        });
+    });
+}
+// ── Summary reporter ──
+/**
+ * Accept an array of SuiteResults and print a color-coded,
+ * human-readable summary to stdout.
+ */
+export function printSummary(results, totalDurationMs) {
+    log.raw("");
+    log.raw("═══════════════════════════════════════");
+    log.raw("  Xcoder SDLC Test Summary");
+    log.raw("═══════════════════════════════════════");
+    log.raw("");
+    // Collect all known labels (including folder suites).
+    const allSuites = [...PREDEFINED_SUITES, ...generateFolderSuites(process.cwd())];
+    for (const r of results) {
+        const icon = r.passed ? "✓" : "✗";
+        const label = allSuites.find((s) => s.name === r.suiteName)?.label ?? r.suiteName;
+        if (r.passed) {
+            log.ok(`${icon} ${label}`);
+        }
+        else {
+            log.fail(`${icon} ${label}`);
+        }
+        if (r.testCount !== null) {
+            const p = r.passedCount ?? 0;
+            const f = r.failedCount ?? 0;
+            const t = r.testCount;
+            log.raw(`  Tests:    ${p} passed, ${f} failed, ${t} total`);
+        }
+        const seconds = (r.durationMs / 1000).toFixed(1);
+        log.raw(`  Duration: ${seconds}s`);
+        if (r.error) {
+            log.dim(`  Error:    ${r.error.slice(0, 200)}`);
+        }
+        log.raw("");
+    }
+    const totalSeconds = (totalDurationMs / 1000).toFixed(1);
+    const passedCount = results.filter((r) => r.passed).length;
+    const totalCount = results.length;
+    if (passedCount === totalCount) {
+        log.ok(`All ${totalCount} suites passed. (${totalSeconds}s total)`);
+    }
+    else {
+        const failedCount = totalCount - passedCount;
+        log.fail(`${failedCount}/${totalCount} suite${failedCount !== 1 ? "s" : ""} failed. (${totalSeconds}s total)`);
+    }
+}
+// ── Command registration ──
+/**
+ * Register the `xcoder test` subcommand.
+ */
+export function registerTestCommand(parent) {
+    parent
+        .command("test")
+        .description("Discover and execute project test suites (unit, e2e, per-folder). Delegates to vitest, captures output, and reports a unified summary.")
+        .option("--suite <unit|e2e|all|folder:name>", "filter suites to run (repeatable for multiple selections)", (val, prev) => [...prev, val], [])
+        .option("--folder <path>", "run only tests under a specific src/folder (repeatable, or use 'all' for every folder)", (val, prev) => [...prev, val], [])
+        .option("--timeout <ms>", "aggregate timeout in milliseconds", (val) => parseInt(val, 10), 300_000)
+        .option("--no-capture", "live-stream test output instead of capturing for summary")
+        .option("--regression", "run all per-folder suites sequentially (equivalent to --folder all)", false)
+        .action(async (opts) => {
+        const root = process.cwd();
+        // Build folder suites on demand.
+        const folderSuites = generateFolderSuites(root);
+        const allSuites = [...PREDEFINED_SUITES, ...folderSuites];
+        // Determine which suites to run.
+        let suites;
+        // --regression flag or --folder all → all folder suites only (not unit/e2e).
+        const folderFilter = opts.regression || opts.folder.includes("all");
+        const explicitFolders = opts.folder.filter((f) => f !== "all" && f.length > 0);
+        if (folderFilter) {
+            // Run all folder suites.
+            suites = [...folderSuites];
+        }
+        else if (explicitFolders.length > 0) {
+            // Run specific folders.
+            suites = folderSuites.filter((s) => {
+                const folderName = s.name.replace(/^folder:/, "");
+                return explicitFolders.some((f) => f === folderName || (s.testFiles && s.testFiles.some((tf) => tf.includes(f))));
+            });
+            if (suites.length === 0) {
+                log.fail(`No test files found in folders: ${explicitFolders.join(", ")}. Available: ${folderSuites.map((s) => s.name.replace(/^folder:/, "")).join(", ") || "(none)"}`);
+                process.exitCode = 2;
+                return;
+            }
+        }
+        else if (opts.suite.length === 0) {
+            // Default: run unit and e2e (backward compatible).
+            suites = [...PREDEFINED_SUITES];
+        }
+        else {
+            // Filter by user selection, deduplicate.
+            const selected = new Set(opts.suite.flatMap((s) => s.split(",")).map((s) => s.trim().toLowerCase()));
+            if (selected.has("all")) {
+                suites = [...allSuites];
+            }
+            else {
+                suites = allSuites.filter((s) => {
+                    if (selected.has(s.name))
+                        return true;
+                    // Also check folder aliases: "folder:agents" or just "agents"
+                    const folderName = s.name.replace(/^folder:/, "");
+                    return selected.has(folderName);
+                });
+            }
+        }
+        if (suites.length === 0) {
+            log.fail(`No matching test suites. Available: ${allSuites.map((s) => s.name).join(", ")}`);
+            process.exitCode = 2;
+            return;
+        }
+        // Check that vitest is available.
+        const checkSpawn = spawn("npx", ["vitest", "--version"], {
+            cwd: root,
+            shell: process.platform === "win32",
+            stdio: "pipe",
+        });
+        let vitestOk = false;
+        try {
+            await new Promise((resolve, reject) => {
+                checkSpawn.on("close", (code) => {
+                    vitestOk = code === 0;
+                    resolve();
+                });
+                checkSpawn.on("error", () => reject(new Error("vitest not found")));
+                setTimeout(() => {
+                    checkSpawn.kill();
+                    resolve();
+                }, 10_000);
+            });
+        }
+        catch {
+            vitestOk = false;
+        }
+        if (!vitestOk) {
+            log.fail("vitest not found. Ensure vitest is installed (npm install vitest) and available via npx.");
+            process.exitCode = 2;
+            return;
+        }
+        // Run suites sequentially.
+        const results = [];
+        const suiteTimeout = Math.floor(opts.timeout / suites.length);
+        const overallStart = Date.now();
+        for (const suite of suites) {
+            const spinner = createSpinner(`Running ${suite.label}…`);
+            try {
+                const result = await runSuite(suite, suiteTimeout, opts.capture);
+                results.push(result);
+                if (result.passed) {
+                    spinner.stop(`${suite.label}: passed`);
+                }
+                else {
+                    spinner.fail(`${suite.label}: failed`);
+                }
+            }
+            catch (e) {
+                const errMsg = e.message;
+                spinner.fail(`${suite.label}: error — ${errMsg}`);
+                results.push({
+                    suiteName: suite.name,
+                    passed: false,
+                    durationMs: Date.now() - overallStart,
+                    testCount: null,
+                    passedCount: null,
+                    failedCount: null,
+                    exitCode: null,
+                    error: errMsg,
+                });
+            }
+        }
+        const totalDurationMs = Date.now() - overallStart;
+        printSummary(results, totalDurationMs);
+        const allPassed = results.every((r) => r.passed);
+        if (!allPassed) {
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/config/loadConfig.d.ts

@@ -0,0 +1,82 @@
+import { getAppDir } from "../skills/skills-root.js";
+export { getAppDir };
+export type LlmProvider = "deepseek" | "openai-compatible" | "anthropic";
+export type AgentRole = "orchestrator" | "sub_agent" | "swarm_agent" | "instance_agent";
+export interface LlmConfig {
+    provider: LlmProvider;
+    base_url?: string;
+    endpoint?: string;
+    model: string;
+    api_key_env?: string;
+    max_tokens: number;
+    temperature: number;
+    thinking?: boolean;
+    reasoning_effort?: "high" | "max";
+    overrides?: Record<string, {
+        model?: string;
+        temperature?: number;
+        thinking?: boolean;
+        reasoning_effort?: "high" | "max";
+    }>;
+    fallback?: Partial<LlmConfig>;
+}
+/**
+ * YAML schema of `.xcoder/config/llm.yaml`. The `default` block is the
+ * global fallback; each role block (`orchestrator`, `sub_agent`,
+ * `swarm_agent`, `instance_agent`) overrides it for that agent role.
+ */
+export interface LlmConfigFile {
+    default?: LlmConfig;
+    orchestrator?: LlmConfig;
+    sub_agent?: LlmConfig;
+    swarm_agent?: LlmConfig;
+    instance_agent?: LlmConfig;
+}
+export declare const AGENT_ROLES: AgentRole[];
+/**
+ * Returns a directory D such that `D/skills` is the resolved skills directory.
+ *
+ * @deprecated Use `resolveSkillsRoot()` from `src/skills/skills-root.ts` — it
+ * is the single source of truth and also tells you which candidate won and
+ * how many packs are actually usable. This wrapper is kept only so existing
+ * importers do not break.
+ */
+export declare function resolveSkillsPath(): string;
+export declare function resolveConfigPath(): string;
+export declare function resolveAgentPath(): string;
+/**
+ * Built-in DeepSeek default — used when no config file exists and as the
+ * fallback for every role. Reads XCODER_MODEL lazily so env changes between
+ * calls are honored.
+ *
+ * Provider `deepseek` is served through DeepSeek's Anthropic-compatible
+ * endpoint (`@anthropic-ai/sdk`, which appends `/v1/messages` to the base
+ * URL), so the canonical root is `https://api.deepseek.com/anthropic` —
+ * NOT the OpenAI-compatible `https://api.deepseek.com/v1`, which would
+ * produce the invalid `.../v1/v1/messages` request path.
+ */
+export declare function deepseekDefaultConfig(): LlmConfig;
+/**
+ * Read `.xcoder/config/llm.yaml` and return the raw per-role schema.
+ * Merge happens in `resolveLlmConfig`, not here. A legacy file shaped as a
+ * single provider block is interpreted as the `default` block.
+ */
+export declare function loadLlmConfigFile(configPath?: string): LlmConfigFile;
+/**
+ * Overlay `~/.xcoder/config.json` (provider / key / model / base_url) on a
+ * resolved block. Switching provider also resets base_url to that provider's
+ * default, so a key is never sent to the previous provider's host.
+ */
+export declare function applyUserLlmOverrides(cfg: LlmConfig): LlmConfig;
+export declare function resolveLlmConfig(role: AgentRole, file?: LlmConfigFile): LlmConfig;
+/**
+ * @deprecated Legacy loader — returns the merged `default` block. New code
+ * should use `loadLlmConfigFile()` + `resolveLlmConfig(role, file)`.
+ */
+export declare function loadLlmConfig(configPath?: string): LlmConfig;
+export declare function resolveModelForSkill(config: LlmConfig, skillName?: string): {
+    model: string;
+    temperature: number;
+    thinking: boolean;
+    reasoningEffort: "high" | "max" | undefined;
+};