muonroi-cli 1.8.0 → 1.8.3

package/dist/src/scaffold/__tests__/init-new.spec.js

@@ -1,378 +0,0 @@
-/**
- * Unit tests for initNewProject scaffolder.
- * All fs + exec operations are mocked — no real I/O or shell-out.
- */
-import { describe, expect, it, vi } from "vitest";
-// ---------------------------------------------------------------------------
-// Mock node:child_process so the bbTemplate path can run without real dotnet.
-//   - `dotnet --version`   → simulate dotnet present / absent via SPAWN_MODE
-//   - `dotnet new list`    → empty (template not installed) so installBBTemplates fires
-//   - `dotnet new install` → ok (status 0)
-// All test exec() calls go through opts.fs.exec (a vi.fn), so spawnSync is
-// only invoked by detectDotnet / detectInstalledBBTemplates / installBBTemplates.
-// ---------------------------------------------------------------------------
-const spawnSyncCalls = [];
-let SPAWN_MODE = "dotnet-absent";
-vi.mock("node:child_process", async () => {
-    const actual = await vi.importActual("node:child_process");
-    return {
-        ...actual,
-        spawnSync: (cmd, args) => {
-            spawnSyncCalls.push({ cmd, args });
-            if (cmd !== "dotnet") {
-                return { status: 1, stdout: "", stderr: "no such command", pid: 0, output: [], signal: null };
-            }
-            if (args[0] === "--version") {
-                return SPAWN_MODE === "dotnet-present"
-                    ? { status: 0, stdout: "9.0.100\n", stderr: "", pid: 0, output: [], signal: null }
-                    : { status: 1, stdout: "", stderr: "not found", pid: 0, output: [], signal: null };
-            }
-            if (args[0] === "new" && args[1] === "list") {
-                // Pretend nothing is installed so installBBTemplates fires.
-                return {
-                    status: 0,
-                    stdout: "Template Name      Short Name\n--------------\n",
-                    stderr: "",
-                    pid: 0,
-                    output: [],
-                    signal: null,
-                };
-            }
-            if (args[0] === "new" && args[1] === "install") {
-                return { status: 0, stdout: "installed", stderr: "", pid: 0, output: [], signal: null };
-            }
-            return { status: 1, stdout: "", stderr: "unhandled", pid: 0, output: [], signal: null };
-        },
-    };
-});
-import { initNewProject } from "../init-new.js";
-// ---------------------------------------------------------------------------
-// Mock fs factory — returns a fresh spy set per test.
-// ---------------------------------------------------------------------------
-function makeMockFs(opts) {
-    const mkdir = vi.fn(async (_p) => {
-        if (opts?.mkdirThrows) {
-            const err = new Error(opts.mkdirThrows);
-            err.code = "EEXIST";
-            throw err;
-        }
-    });
-    const writeFile = vi.fn(async (_p, _content) => { });
-    const exec = vi.fn(async (_cmd, _cwd) => ({ stdout: "", stderr: "" }));
-    const exists = vi.fn((_p) => opts?.existsReturns ?? false);
-    return { mkdir, writeFile, exec, exists };
-}
-// ---------------------------------------------------------------------------
-// Test 1: scaffolds expected file tree (react)
-// ---------------------------------------------------------------------------
-describe("initNewProject — react", () => {
-    it("creates expected directories and files for react stack (FE-only, no bbTemplate)", async () => {
-        const fs = makeMockFs();
-        const result = await initNewProject({
-            projectName: "test-app",
-            feStack: "react",
-            projectsRoot: "/tmp/projects",
-            fs,
-        });
-        // Directories created: project root, server, client, client/src
-        const mkdirPaths = fs.mkdir.mock.calls.map((c) => c[0]);
-        expect(mkdirPaths.some((p) => p.endsWith("test-app"))).toBe(true);
-        expect(mkdirPaths.some((p) => p.includes("server"))).toBe(true);
-        expect(mkdirPaths.some((p) => p.endsWith("client"))).toBe(true);
-        expect(mkdirPaths.some((p) => p.includes("client") && p.endsWith("src"))).toBe(true);
-        // Files written
-        expect(result.files).toContain("package.json");
-        expect(result.files).toContain("client/package.json");
-        expect(result.files).toContain("client/vite.config.ts");
-        expect(result.files).toContain("client/index.html");
-        expect(result.files).toContain("client/src/main.tsx");
-        // No bbTemplate → no BE scaffold commands run (clone fallback retired).
-        const execCmds = fs.exec.mock.calls.map((c) => c[0]);
-        expect(execCmds.every((cmd) => !cmd.startsWith("git clone"))).toBe(true);
-        expect(execCmds.every((cmd) => !cmd.startsWith("dotnet"))).toBe(true);
-        // main.tsx contains SemanticProvider
-        const writeFileCalls = fs.writeFile.mock.calls;
-        const mainTsxCall = writeFileCalls.find((c) => c[0].endsWith("main.tsx"));
-        expect(mainTsxCall).toBeDefined();
-        expect(mainTsxCall[1]).toContain("SemanticProvider");
-        // projectDir returned correctly
-        expect(result.projectDir).toContain("test-app");
-    });
-});
-// ---------------------------------------------------------------------------
-// Test 2: scaffolds expected file tree (angular)
-// ---------------------------------------------------------------------------
-describe("initNewProject — angular", () => {
-    it("creates expected directories and files for angular stack", async () => {
-        const fs = makeMockFs();
-        const result = await initNewProject({
-            projectName: "ng-app",
-            feStack: "angular",
-            projectsRoot: "/tmp/projects",
-            fs,
-        });
-        // Directories: project root, server, client, client/src, client/src/app
-        const mkdirPaths = fs.mkdir.mock.calls.map((c) => c[0]);
-        expect(mkdirPaths.some((p) => p.includes("app"))).toBe(true);
-        // Files written
-        expect(result.files).toContain("package.json");
-        expect(result.files).toContain("client/package.json");
-        expect(result.files).toContain("client/tsconfig.json");
-        expect(result.files).toContain("client/src/main.ts");
-        expect(result.files).toContain("client/src/app/app.component.ts");
-        // No react files
-        expect(result.files).not.toContain("client/vite.config.ts");
-        expect(result.files).not.toContain("client/src/main.tsx");
-        // app.component.ts uses muonroiSemantic directive
-        const writeFileCalls = fs.writeFile.mock.calls;
-        const componentCall = writeFileCalls.find((c) => c[0].endsWith("app.component.ts"));
-        expect(componentCall).toBeDefined();
-        expect(componentCall[1]).toContain("muonroiSemantic");
-        expect(componentCall[1]).toContain("SemanticDirective");
-    });
-});
-// ---------------------------------------------------------------------------
-// Test 3: feStack=none skips client/**
-// ---------------------------------------------------------------------------
-describe("initNewProject — none", () => {
-    it("skips client directory and files when feStack is none", async () => {
-        const fs = makeMockFs();
-        const result = await initNewProject({
-            projectName: "be-only",
-            feStack: "none",
-            projectsRoot: "/tmp/projects",
-            fs,
-        });
-        // No client/* files
-        const clientFiles = result.files.filter((f) => f.startsWith("client/"));
-        expect(clientFiles).toHaveLength(0);
-        // No client directories created
-        const mkdirPaths = fs.mkdir.mock.calls.map((c) => c[0]);
-        expect(mkdirPaths.every((p) => !p.includes("client"))).toBe(true);
-        // root package.json still written
-        expect(result.files).toContain("package.json");
-        // No BE commands either (no bbTemplate provided).
-        expect(fs.exec.mock.calls.length).toBe(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// Test 4: refuses if projectDir already exists
-// ---------------------------------------------------------------------------
-describe("initNewProject — existence guard", () => {
-    it("rejects with descriptive error when target directory already exists", async () => {
-        const fs = makeMockFs({ existsReturns: true });
-        await expect(initNewProject({
-            projectName: "existing-app",
-            feStack: "react",
-            projectsRoot: "/tmp/projects",
-            fs,
-        })).rejects.toThrow(/already exists/i);
-    });
-});
-// ---------------------------------------------------------------------------
-// Test 5: validates projectName
-// ---------------------------------------------------------------------------
-describe("initNewProject — name validation", () => {
-    it("rejects path traversal in projectName", async () => {
-        const fs = makeMockFs();
-        await expect(initNewProject({
-            projectName: "../escape",
-            feStack: "react",
-            fs,
-        })).rejects.toThrow(/path traversal/i);
-    });
-    it("rejects empty project name", async () => {
-        const fs = makeMockFs();
-        await expect(initNewProject({
-            projectName: "",
-            feStack: "react",
-            fs,
-        })).rejects.toThrow(/empty/i);
-    });
-    it("rejects name with backslash traversal", async () => {
-        const fs = makeMockFs();
-        await expect(initNewProject({
-            projectName: "foo\\bar",
-            feStack: "react",
-            fs,
-        })).rejects.toThrow(/path traversal/i);
-    });
-    it("rejects name with invalid characters (spaces)", async () => {
-        const fs = makeMockFs();
-        await expect(initNewProject({
-            projectName: "my app",
-            feStack: "react",
-            fs,
-        })).rejects.toThrow(/invalid/i);
-    });
-});
-// ---------------------------------------------------------------------------
-// Test 6 (Plan 23-01b): bbTemplate path auto-installs missing template and
-// invokes `dotnet add package` per EE package.
-// ---------------------------------------------------------------------------
-describe("initNewProject — bbTemplate + EE packages (Plan 23-01b)", () => {
-    it("auto-installs the chosen template when missing and runs `dotnet add package` per EE package", async () => {
-        SPAWN_MODE = "dotnet-present";
-        spawnSyncCalls.length = 0;
-        const fs = makeMockFs();
-        const result = await initNewProject({
-            projectName: "todo-api",
-            feStack: "none",
-            projectsRoot: "/tmp/projects",
-            bbTemplate: {
-                shortName: "mr-base-sln",
-                nugetId: "Muonroi.BaseTemplate",
-                version: "1.0.0-alpha.3",
-            },
-            eePackages: ["Muonroi.AspNetCore", "Muonroi.Tenancy"],
-            fs,
-        });
-        // installBBTemplates was invoked with the selective nugetId.
-        const installCall = spawnSyncCalls.find((c) => c.cmd === "dotnet" && c.args[0] === "new" && c.args[1] === "install");
-        expect(installCall).toBeDefined();
-        expect(installCall.args[2]).toBe("Muonroi.BaseTemplate@1.0.0-alpha.3");
-        // Only the chosen template was installed — sibling templates left alone.
-        const installRefs = spawnSyncCalls
-            .filter((c) => c.args[0] === "new" && c.args[1] === "install")
-            .map((c) => c.args[2]);
-        expect(installRefs).toEqual(["Muonroi.BaseTemplate@1.0.0-alpha.3"]);
-        // The exec recorder should contain `dotnet new mr-base-sln` and restore.
-        // The add-package loop is gated on findPrimaryCsproj() locating a real
-        // .csproj on disk — in this mock environment the template scaffold output
-        // doesn't exist, so the loop correctly skips all packages (with a single
-        // stderr warning). Tested separately against real scaffold output below
-        // via the dedicated findPrimaryCsproj unit test.
-        const execCmds = fs.exec.mock.calls.map((c) => [c[0], c[1]]);
-        expect(execCmds.some(([cmd]) => cmd.startsWith("dotnet new mr-base-sln "))).toBe(true);
-        expect(execCmds.some(([cmd]) => cmd.includes("restore --nologo"))).toBe(true);
-        const addPackageCalls = execCmds.filter(([cmd]) => / add .* package /.test(cmd));
-        expect(addPackageCalls.length).toBe(0);
-        // No legacy `git clone` ever runs.
-        expect(execCmds.every(([cmd]) => !cmd.startsWith("git clone"))).toBe(true);
-        // Result flagged with template usage.
-        expect(result.usedDotnetTemplate).toBe(true);
-    });
-    it("throws (no clone fallback) when dotnet is unavailable but bbTemplate is requested", async () => {
-        SPAWN_MODE = "dotnet-absent";
-        spawnSyncCalls.length = 0;
-        const fs = makeMockFs();
-        await expect(initNewProject({
-            projectName: "todo-api3",
-            feStack: "none",
-            projectsRoot: "/tmp/projects",
-            bbTemplate: {
-                shortName: "mr-base-sln",
-                nugetId: "Muonroi.BaseTemplate",
-                version: "1.0.0-alpha.3",
-            },
-            fs,
-        })).rejects.toThrow(/Scaffold failed/i);
-        // No git clone command ever runs (no fallback).
-        const execCmds = fs.exec.mock.calls.map((c) => c[0]);
-        expect(execCmds.every((cmd) => !cmd.startsWith("git clone"))).toBe(true);
-    });
-});
-// ---------------------------------------------------------------------------
-// findPrimaryCsproj — verifies heuristic against synthetic BB-shaped trees.
-// These shapes are derived from MANUAL scaffold runs of mr-micro-sln@1.10.0
-// and mr-mod-sln@1.10.0 (verified 2026-05-19 in /tmp/muonroi-scaffold-test).
-// ---------------------------------------------------------------------------
-import path from "node:path";
-import { findPrimaryCsproj } from "../init-new.js";
-function makeFsTree(files) {
-    // files: { "C:/x/y/foo.csproj": "<Project Sdk=...></Project>", ... }
-    const dirs = new Set();
-    for (const p of Object.keys(files)) {
-        let cur = p;
-        while (true) {
-            const parent = cur.replace(/[/\\][^/\\]+$/, "");
-            if (parent === cur || parent === "")
-                break;
-            dirs.add(parent);
-            cur = parent;
-        }
-    }
-    return {
-        readdir: (p) => {
-            const entries = [];
-            const seen = new Set();
-            const _prefix = `${p.replace(/[/\\]$/, "")}/`;
-            for (const f of Object.keys(files)) {
-                const norm = f.replace(/\\/g, "/");
-                const np = `${p.replace(/\\/g, "/").replace(/\/$/, "")}/`;
-                if (!norm.startsWith(np))
-                    continue;
-                const rest = norm.slice(np.length);
-                const seg = rest.split("/")[0];
-                if (!seg || seen.has(seg))
-                    continue;
-                seen.add(seg);
-                const isFile = rest === seg;
-                entries.push({ name: seg, isDir: !isFile, isFile });
-            }
-            for (const d of dirs) {
-                const norm = d.replace(/\\/g, "/");
-                const np = `${p.replace(/\\/g, "/").replace(/\/$/, "")}/`;
-                if (!norm.startsWith(np))
-                    continue;
-                const rest = norm.slice(np.length);
-                const seg = rest.split("/")[0];
-                if (!seg || seen.has(seg))
-                    continue;
-                seen.add(seg);
-                entries.push({ name: seg, isDir: true, isFile: false });
-            }
-            if (entries.length === 0 && !dirs.has(p.replace(/\\/g, "/").replace(/\/$/, ""))) {
-                throw new Error("ENOENT");
-            }
-            return entries;
-        },
-        readFile: (p) => {
-            const norm = p.replace(/\\/g, "/");
-            for (const [k, v] of Object.entries(files)) {
-                if (k.replace(/\\/g, "/") === norm)
-                    return v;
-            }
-            throw new Error("ENOENT");
-        },
-    };
-}
-describe("findPrimaryCsproj — BB template heuristic", () => {
-    const webSdk = `<Project Sdk="Microsoft.NET.Sdk.Web"><PropertyGroup/></Project>`;
-    const libSdk = `<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup/></Project>`;
-    it("picks the Gateway Web SDK csproj for mr-micro-sln shape", () => {
-        const fs = makeFsTree({
-            "C:/app/src/Gateways/App.Gateway/App.Gateway.csproj": webSdk,
-            "C:/app/src/Services/App.Catalog/App.Catalog.csproj": webSdk,
-            "C:/app/src/Services/App.Core/App.Core.csproj": libSdk,
-            "C:/app/src/Services/App.Data/App.Data.csproj": libSdk,
-        });
-        expect(findPrimaryCsproj("C:/app", 6, fs)).toBe(path.join("C:/app", "src", "Gateways", "App.Gateway", "App.Gateway.csproj"));
-    });
-    it("picks the Host Web SDK csproj for mr-mod-sln shape", () => {
-        const fs = makeFsTree({
-            "C:/app/src/Host/App.Host/App.Host.csproj": webSdk,
-            "C:/app/src/Modules/Catalog/App.Modules.Catalog.csproj": libSdk,
-            "C:/app/src/Shared/App.Kernel/App.Kernel.csproj": libSdk,
-        });
-        expect(findPrimaryCsproj("C:/app", 6, fs)).toBe(path.join("C:/app", "src", "Host", "App.Host", "App.Host.csproj"));
-    });
-    it("excludes test projects when picking primary", () => {
-        const fs = makeFsTree({
-            "C:/app/App.Tests/App.Tests.csproj": webSdk, // would otherwise win on depth
-            "C:/app/src/App.Api/App.Api.csproj": webSdk,
-        });
-        expect(findPrimaryCsproj("C:/app", 6, fs)).toBe(path.join("C:/app", "src", "App.Api", "App.Api.csproj"));
-    });
-    it("returns null when no .csproj is found", () => {
-        const fs = makeFsTree({ "C:/app/README.md": "" });
-        expect(findPrimaryCsproj("C:/app", 6, fs)).toBeNull();
-    });
-    it("falls back to non-Web SDK csproj when no Web SDK exists", () => {
-        const fs = makeFsTree({
-            "C:/app/src/App.Lib/App.Lib.csproj": libSdk,
-        });
-        expect(findPrimaryCsproj("C:/app", 6, fs)).toBe(path.join("C:/app", "src", "App.Lib", "App.Lib.csproj"));
-    });
-});
-//# sourceMappingURL=init-new.spec.js.map

package/dist/src/scaffold/__tests__/install-bb-templates.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/scaffold/__tests__/install-bb-templates.spec.js

@@ -1,77 +0,0 @@
-/**
- * Plan 23-fix — focused tests for installBBTemplates exit-code detection.
- *
- * Background: `dotnet new install` on some SDKs prints warnings about stale
- * template paths (Failed to scan D:\...) and exits non-zero EVEN WHEN the
- * install succeeded. The fix treats stdout containing "Success:" as success
- * regardless of exit status. Without this, the TUI claimed "template could
- * not be applied" + a misleading "requires SDK X.0+; you have Y.Y.YYY" line
- * — observed in production session 36798f9c33fd (machine had SDK 9.0.313,
- * template required 9.0).
- */
-import { describe, expect, it, vi } from "vitest";
-const stubResult = (over) => ({
-    status: 0,
-    stdout: "",
-    stderr: "",
-    pid: 0,
-    output: [],
-    signal: null,
-    ...over,
-});
-let MOCK_INSTALL_RESULT = stubResult({});
-vi.mock("node:child_process", async () => {
-    const actual = await vi.importActual("node:child_process");
-    return {
-        ...actual,
-        spawnSync: (cmd, args) => {
-            if (cmd === "dotnet" && args[0] === "new" && args[1] === "install") {
-                return MOCK_INSTALL_RESULT;
-            }
-            return stubResult({ status: 1, stderr: "unhandled" });
-        },
-    };
-});
-import { installBBTemplates } from "../init-new.js";
-describe("installBBTemplates — Plan 23-fix exit code detection", () => {
-    it("returns true when status === 0 (normal success)", () => {
-        MOCK_INSTALL_RESULT = stubResult({
-            status: 0,
-            stdout: "Success: Muonroi.BaseTemplate::1.0.0-alpha.3 installed the following templates:\n",
-        });
-        expect(installBBTemplates(["Muonroi.BaseTemplate"])).toBe(true);
-    });
-    it("returns true when status !== 0 but stdout has 'Success:' (stale scan-warning case)", () => {
-        // This is the exact failure mode from session 36798f9c33fd — dotnet emits
-        // "Warning: Failed to scan D:\Personal\Project\..." for stale template
-        // references, returns status=1, but the install itself succeeded.
-        MOCK_INSTALL_RESULT = stubResult({
-            status: 1,
-            stdout: "The following template packages will be installed:\n   Muonroi.BaseTemplate::1.0.0-alpha.3\n" +
-                "Warning: Failed to scan D:\\Personal\\Project\\Muonroi.BaseTemplate.\n" +
-                "Success: Muonroi.BaseTemplate::1.0.0-alpha.3 installed the following templates:\n",
-            stderr: "stale scan warnings",
-        });
-        expect(installBBTemplates(["Muonroi.BaseTemplate"])).toBe(true);
-    });
-    it("returns true when stdout contains 'is already installed' (legacy idempotency)", () => {
-        MOCK_INSTALL_RESULT = stubResult({
-            status: 1,
-            stdout: "Muonroi.BaseTemplate::1.0.0-alpha.3 is already installed.\n",
-        });
-        expect(installBBTemplates(["Muonroi.BaseTemplate"])).toBe(true);
-    });
-    it("returns true when status === 106 (legacy already-installed code)", () => {
-        MOCK_INSTALL_RESULT = stubResult({ status: 106, stdout: "" });
-        expect(installBBTemplates(["Muonroi.BaseTemplate"])).toBe(true);
-    });
-    it("returns false on genuine failure (non-zero status, no Success marker)", () => {
-        MOCK_INSTALL_RESULT = stubResult({
-            status: 1,
-            stdout: "NU1101: Unable to find package Muonroi.BaseTemplate.\n",
-            stderr: "package not found",
-        });
-        expect(installBBTemplates(["Muonroi.BaseTemplate"])).toBe(false);
-    });
-});
-//# sourceMappingURL=install-bb-templates.spec.js.map

package/dist/src/scaffold/__tests__/point-to-existing.spec.d.ts

@@ -1,7 +0,0 @@
-/**
- * Unit tests for pointToExisting().
- *
- * All filesystem operations use real tmp dirs so we don't need to mock fs.
- * detectVerifyRecipe is always mocked so there are no orchestrator calls.
- */
-export {};

package/dist/src/scaffold/__tests__/point-to-existing.spec.js

@@ -1,94 +0,0 @@
-/**
- * Unit tests for pointToExisting().
- *
- * All filesystem operations use real tmp dirs so we don't need to mock fs.
- * detectVerifyRecipe is always mocked so there are no orchestrator calls.
- */
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { pointToExisting } from "../point-to-existing.js";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-let tmpRoot;
-beforeEach(() => {
-    tmpRoot = mkdtempSync(path.join(tmpdir(), "point-to-existing-test-"));
-});
-afterEach(() => {
-    rmSync(tmpRoot, { recursive: true, force: true });
-});
-// ---------------------------------------------------------------------------
-// Test 1: existing dir + recipe found → ok
-// ---------------------------------------------------------------------------
-describe("pointToExisting — success", () => {
-    it("returns ok=true when dir exists and detectVerifyRecipe returns a recipe", async () => {
-        const mockRecipe = { kind: "bun-test" };
-        const detectVerifyRecipe = vi.fn(async (_cwd) => mockRecipe);
-        const result = await pointToExisting({
-            path: tmpRoot,
-            detectVerifyRecipe,
-        });
-        expect(result.ok).toBe(true);
-        expect(result.reason).toBe("ok");
-        expect(result.recipe).toEqual(mockRecipe);
-        expect(path.isAbsolute(result.absolutePath)).toBe(true);
-        // detectVerifyRecipe called with the resolved absolute path
-        expect(detectVerifyRecipe).toHaveBeenCalledOnce();
-        expect(detectVerifyRecipe.mock.calls[0][0]).toBe(result.absolutePath);
-    });
-});
-// ---------------------------------------------------------------------------
-// Test 2: nonexistent path → not_a_dir
-// ---------------------------------------------------------------------------
-describe("pointToExisting — nonexistent path", () => {
-    it("returns not_a_dir when path does not exist", async () => {
-        const detectVerifyRecipe = vi.fn(async () => ({ kind: "bun-test" }));
-        const result = await pointToExisting({
-            path: path.join(tmpRoot, "nonexistent-dir-xyz"),
-            detectVerifyRecipe,
-        });
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe("not_a_dir");
-        // detectVerifyRecipe must NOT be called when path is invalid
-        expect(detectVerifyRecipe).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// Test 3: path is a file, not a directory → not_a_dir
-// ---------------------------------------------------------------------------
-describe("pointToExisting — file instead of directory", () => {
-    it("returns not_a_dir when path points to a file", async () => {
-        const filePath = path.join(tmpRoot, "some-file.txt");
-        writeFileSync(filePath, "hello");
-        const detectVerifyRecipe = vi.fn(async () => ({ kind: "bun-test" }));
-        const result = await pointToExisting({
-            path: filePath,
-            detectVerifyRecipe,
-        });
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe("not_a_dir");
-        expect(detectVerifyRecipe).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// Test 4: dir exists but detectVerifyRecipe returns null → no_recipe
-// ---------------------------------------------------------------------------
-describe("pointToExisting — no recipe", () => {
-    it("returns no_recipe when detectVerifyRecipe returns null", async () => {
-        const subdir = path.join(tmpRoot, "project-no-recipe");
-        mkdirSync(subdir);
-        const detectVerifyRecipe = vi.fn(async (_cwd) => null);
-        const result = await pointToExisting({
-            path: subdir,
-            detectVerifyRecipe,
-        });
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe("no_recipe");
-        expect(result.absolutePath).toBeTruthy();
-        // detectVerifyRecipe was called (path was valid)
-        expect(detectVerifyRecipe).toHaveBeenCalledOnce();
-    });
-});
-//# sourceMappingURL=point-to-existing.spec.js.map

package/dist/src/self-qa/__tests__/agentic-context.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/self-qa/__tests__/agentic-context.test.js

@@ -1,98 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildAgenticContext } from "../agentic-context.js";
-const frame = (over = {}) => ({
-    mode: "live",
-    version: "0.4.0",
-    seq: 1,
-    ts: Date.now(),
-    nodes: [
-        { id: "composer", role: "textbox", name: "Prompt", value: "" },
-        { id: "askcard", role: "dialog", name: "What scope?", isModal: true },
-    ],
-    focus: "composer",
-    modals: ["askcard"],
-    ...over,
-});
-describe("agentic-context", () => {
-    it("renders askcard question + options when pinned", () => {
-        const f = frame({
-            nodes: [
-                {
-                    id: "askcard",
-                    role: "dialog",
-                    name: "What scope?",
-                    isModal: true,
-                    children: [
-                        { id: "opt-small", role: "listitem", name: "small" },
-                        { id: "opt-large", role: "listitem", name: "large" },
-                    ],
-                },
-            ],
-        });
-        const ctx = buildAgenticContext(null, f, [], { pinIds: ["askcard"] });
-        expect(ctx.prompt).toContain("Pinned nodes");
-        expect(ctx.prompt).toContain("opt-small");
-        expect(ctx.prompt).toContain("opt-large");
-    });
-    it("shows delta vs previous frame", () => {
-        const prev = frame();
-        const next = frame({
-            seq: 2,
-            focus: "askcard",
-            nodes: [
-                { id: "composer", role: "textbox", name: "Prompt", value: "/ideal" },
-                { id: "askcard", role: "dialog", name: "What scope?", isModal: true },
-            ],
-        });
-        const ctx = buildAgenticContext(prev, next, []);
-        expect(ctx.prompt).toContain("Changed since last turn");
-        expect(ctx.prompt).toContain("composer{value");
-        expect(ctx.prompt).toContain("focus: composer → askcard");
-    });
-    it("renders event tail in newest-first order with semantic shortcuts", () => {
-        const events = [
-            { t: "event", kind: "toast", level: "info", text: "saved" },
-            {
-                t: "event",
-                kind: "askcard-open",
-                questionId: "q1",
-                question: "What scope?",
-                phase: "scope",
-                optionCount: 3,
-            },
-            {
-                t: "event",
-                kind: "route-decision",
-                path: "council",
-                complexity: "complex",
-                forceCouncil: true,
-                runId: "r1",
-            },
-        ];
-        const ctx = buildAgenticContext(null, frame(), events);
-        const idxRoute = ctx.prompt.indexOf("route-decision");
-        const idxAsk = ctx.prompt.indexOf("askcard-open");
-        expect(idxRoute).toBeGreaterThan(-1);
-        expect(idxAsk).toBeGreaterThan(-1);
-        // newest first: route-decision should appear before askcard-open
-        expect(idxRoute).toBeLessThan(idxAsk);
-        expect(ctx.prompt).toContain('q="What scope?"');
-    });
-    it("truncates when exceeding maxChars", () => {
-        const events = Array.from({ length: 100 }, (_, i) => ({
-            t: "event",
-            kind: "toast",
-            level: "info",
-            text: `noisy event ${i} `.repeat(50),
-        }));
-        const ctx = buildAgenticContext(null, frame(), events, { maxChars: 500 });
-        expect(ctx.truncated).toBe(true);
-        expect(ctx.prompt.length).toBeLessThanOrEqual(550);
-        expect(ctx.prompt).toContain("truncated");
-    });
-    it("estimatedTokens roughly matches chars/4", () => {
-        const ctx = buildAgenticContext(null, frame(), []);
-        expect(Math.abs(ctx.estimatedTokens - Math.ceil(ctx.prompt.length / 4))).toBeLessThan(2);
-    });
-});
-//# sourceMappingURL=agentic-context.test.js.map

package/dist/src/self-qa/__tests__/agentic-loop.test.d.ts

@@ -1 +0,0 @@
-export {};