muonroi-cli 1.8.1 → 1.8.4

package/dist/src/scaffold/__tests__/continue-as-council.spec.js

@@ -1,102 +0,0 @@
-/**
- * Unit tests for continueAsCouncil() — Task 5.5.
- *
- * All filesystem writes are injected via opts.fs so the real filesystem is
- * never touched. runCouncil is also injected so no real orchestrator runs.
- *
- * Key invariant checked by Test 2: the source file must contain no reference
- * to "runVerify" — guaranteeing it can never accidentally re-enter CB-3.
- */
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { describe, expect, it, vi } from "vitest";
-import { continueAsCouncil } from "../continue-as-council.js";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Build an async iterable that emits delta chunks then done. */
-async function* makeCouncilStream(chunks) {
-    for (const c of chunks) {
-        yield { type: "delta", content: c };
-    }
-    yield { type: "done" };
-}
-// ---------------------------------------------------------------------------
-// Test 1: happy-path — delta chunks are collected and written to spec.md
-// ---------------------------------------------------------------------------
-describe("continueAsCouncil — happy path", () => {
-    it("writes spec.md with both delta strings and returns hasContent: true", async () => {
-        const writeFile = vi.fn(async (_p, _content) => { });
-        const result = await continueAsCouncil({
-            prompt: "build todo",
-            outputDir: "/tmp/proj",
-            runCouncil: () => makeCouncilStream(["First council note.", " Second council note."]),
-            fs: { writeFile },
-        });
-        // writeFile called exactly once
-        expect(writeFile).toHaveBeenCalledOnce();
-        // path ends in spec.md
-        expect(result.specPath.endsWith("spec.md")).toBe(true);
-        // hasContent flag
-        expect(result.hasContent).toBe(true);
-        // content includes both delta strings
-        const [, written] = writeFile.mock.calls[0];
-        expect(written).toContain("First council note.");
-        expect(written).toContain("Second council note.");
-    });
-});
-// ---------------------------------------------------------------------------
-// Test 2 (critical): source file must NOT reference runVerify
-// ---------------------------------------------------------------------------
-describe("continueAsCouncil — no runVerify dependency", () => {
-    it("source file contains no reference to runVerify", () => {
-        const srcPath = resolve(__dirname, "../continue-as-council.ts");
-        const content = readFileSync(srcPath, "utf-8");
-        expect(content).not.toContain("runVerify");
-    });
-});
-// ---------------------------------------------------------------------------
-// Test 3: spec.md content has recognizable heading and original prompt
-// ---------------------------------------------------------------------------
-describe("continueAsCouncil — spec.md content", () => {
-    it("spec.md includes heading and original prompt text", async () => {
-        const writeFile = vi.fn(async (_p, _content) => { });
-        await continueAsCouncil({
-            prompt: "design a recommendation engine",
-            outputDir: "/tmp/spec-test",
-            runCouncil: () => makeCouncilStream(["Some council output."]),
-            fs: { writeFile },
-        });
-        const [, written] = writeFile.mock.calls[0];
-        // Has recognizable heading
-        expect(written).toContain("# Council brainstorm output");
-        // Contains original prompt
-        expect(written).toContain("design a recommendation engine");
-    });
-});
-// ---------------------------------------------------------------------------
-// Test 4: empty council stream → hasContent false, spec.md still written
-// ---------------------------------------------------------------------------
-describe("continueAsCouncil — empty stream", () => {
-    it("writes spec.md even when council produces no content, hasContent: false", async () => {
-        const writeFile = vi.fn(async (_p, _content) => { });
-        async function* emptyStream() {
-            yield { type: "done" };
-        }
-        const result = await continueAsCouncil({
-            prompt: "empty prompt",
-            outputDir: "/tmp/empty-test",
-            runCouncil: emptyStream,
-            fs: { writeFile },
-        });
-        expect(result.hasContent).toBe(false);
-        // spec.md is still written
-        expect(writeFile).toHaveBeenCalledOnce();
-        const [, written] = writeFile.mock.calls[0];
-        // Still has the heading
-        expect(written).toContain("# Council brainstorm output");
-        // Notes no content was produced
-        expect(written).toContain("No content was produced");
-    });
-});
-//# sourceMappingURL=continue-as-council.spec.js.map

package/dist/src/scaffold/__tests__/dotnet-assembly-name.test.d.ts

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

package/dist/src/scaffold/__tests__/dotnet-assembly-name.test.js

@@ -1,27 +0,0 @@
-/**
- * Verifies kebab → PascalCase conversion used for `dotnet new -n`.
- * Background: original code passed the kebab project name verbatim, which
- * produced .csproj like `todo-app.Catalog.csproj` and C# namespaces like
- * `todo_app.Catalog.*` (C# can't have dashes — dotnet mangles to underscore).
- * The fix uses PascalCase only for the .NET assembly + namespace prefix,
- * keeping kebab for the outer folder and package.json.
- */
-import { describe, expect, it } from "vitest";
-import { toDotNetAssemblyName } from "../init-new.js";
-describe("toDotNetAssemblyName", () => {
-    it.each([
-        ["todo-app", "TodoApp"],
-        ["my-cool-svc", "MyCoolSvc"],
-        ["my_cool-svc", "MyCoolSvc"],
-        ["project1", "Project1"],
-        ["a", "A"],
-        ["one-two-three-four", "OneTwoThreeFour"],
-        ["UPPERCASE-only", "UppercaseOnly"],
-    ])("'%s' → '%s'", (input, expected) => {
-        expect(toDotNetAssemblyName(input)).toBe(expected);
-    });
-    it("matches PascalCase shape", () => {
-        expect(toDotNetAssemblyName("any-name")).toMatch(/^[A-Z][a-zA-Z0-9]*$/);
-    });
-});
-//# sourceMappingURL=dotnet-assembly-name.test.js.map

package/dist/src/scaffold/__tests__/fe-scaffold-contents.test.d.ts

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

package/dist/src/scaffold/__tests__/fe-scaffold-contents.test.js

@@ -1,106 +0,0 @@
-/**
- * Verifies the FE scaffold writes a real app skeleton — not just a hello-world.
- * Backed by the Todo_App/client review: scaffolded clients were too thin
- * (no env config, no typed API client, no error boundary, no design tokens).
- */
-import { describe, expect, it } from "vitest";
-import { initNewProject } from "../init-new.js";
-function makeFs() {
-    const paths = new Set();
-    const files = new Map();
-    return {
-        paths,
-        files,
-        mkdir: async (p) => {
-            paths.add(p);
-        },
-        writeFile: async (p, c) => {
-            files.set(p.replace(/\\/g, "/"), c);
-        },
-        exec: async () => ({ stdout: "", stderr: "" }),
-        exists: () => false,
-    };
-}
-describe("FE scaffold contents (React)", () => {
-    it("writes env, tsconfig, gitignore, README, api/, components/, styles/", async () => {
-        const fs = makeFs();
-        await initNewProject({
-            projectName: "demo-app",
-            feStack: "react",
-            projectsRoot: "/tmp",
-            fs,
-        });
-        const has = (suffix) => Array.from(fs.files.keys()).some((p) => p.endsWith(suffix));
-        expect(has("client/.env.example"), ".env.example").toBe(true);
-        expect(has("client/.gitignore"), ".gitignore").toBe(true);
-        expect(has("client/README.md"), "README.md").toBe(true);
-        expect(has("client/tsconfig.json"), "tsconfig.json").toBe(true);
-        expect(has("client/src/api/client.ts"), "api/client.ts").toBe(true);
-        expect(has("client/src/api/types.ts"), "api/types.ts").toBe(true);
-        expect(has("client/src/components/ErrorBoundary.tsx"), "ErrorBoundary").toBe(true);
-        expect(has("client/src/styles/app.css"), "styles/app.css").toBe(true);
-    });
-    it("tsconfig has strict: true", async () => {
-        const fs = makeFs();
-        await initNewProject({ projectName: "demo-app", feStack: "react", projectsRoot: "/tmp", fs });
-        const tsconfig = Array.from(fs.files.entries()).find(([p]) => p.endsWith("client/tsconfig.json"))?.[1];
-        expect(tsconfig).toBeTruthy();
-        const parsed = JSON.parse(tsconfig);
-        expect(parsed.compilerOptions.strict).toBe(true);
-    });
-    it("env.example references VITE_API_BASE, no hardcoded URL in api/client", async () => {
-        const fs = makeFs();
-        await initNewProject({ projectName: "demo-app", feStack: "react", projectsRoot: "/tmp", fs });
-        const env = Array.from(fs.files.entries()).find(([p]) => p.endsWith("client/.env.example"))?.[1];
-        const api = Array.from(fs.files.entries()).find(([p]) => p.endsWith("client/src/api/client.ts"))?.[1];
-        expect(env).toContain("VITE_API_BASE");
-        expect(api).toContain("import.meta.env.VITE_API_BASE");
-        // No hardcoded localhost URL in the api client body
-        expect(api).not.toMatch(/http:\/\/localhost/);
-    });
-    it("main.tsx still imports SemanticProvider and now imports ErrorBoundary + styles", async () => {
-        const fs = makeFs();
-        await initNewProject({ projectName: "demo-app", feStack: "react", projectsRoot: "/tmp", fs });
-        const main = Array.from(fs.files.entries()).find(([p]) => p.endsWith("client/src/main.tsx"))?.[1];
-        expect(main).toContain("SemanticProvider");
-        expect(main).toContain("ErrorBoundary");
-        expect(main).toContain("./styles/app.css");
-    });
-});
-describe("FE scaffold contents (Angular)", () => {
-    it("writes environments/, api/, error-handler, styles, README, gitignore", async () => {
-        const fs = makeFs();
-        await initNewProject({
-            projectName: "demo-app",
-            feStack: "angular",
-            projectsRoot: "/tmp",
-            fs,
-        });
-        const has = (suffix) => Array.from(fs.files.keys()).some((p) => p.endsWith(suffix));
-        expect(has("client/.gitignore"), ".gitignore").toBe(true);
-        expect(has("client/README.md"), "README.md").toBe(true);
-        expect(has("client/src/styles.css"), "styles.css").toBe(true);
-        expect(has("client/src/environments/environment.ts"), "environment.ts").toBe(true);
-        expect(has("client/src/environments/environment.prod.ts"), "environment.prod.ts").toBe(true);
-        expect(has("client/src/api/api.service.ts"), "api.service.ts").toBe(true);
-        expect(has("client/src/api/types.ts"), "api types").toBe(true);
-        expect(has("client/src/app/error-handler.ts"), "error-handler.ts").toBe(true);
-    });
-    it("main.ts wires AppErrorHandler + provideHttpClient + styles", async () => {
-        const fs = makeFs();
-        await initNewProject({ projectName: "demo-app", feStack: "angular", projectsRoot: "/tmp", fs });
-        const main = Array.from(fs.files.entries()).find(([p]) => p.endsWith("client/src/main.ts"))?.[1];
-        expect(main).toContain("AppErrorHandler");
-        expect(main).toContain("provideHttpClient");
-        expect(main).toContain("./styles.css");
-    });
-    it("environment.ts has apiBase, api.service reads from environment", async () => {
-        const fs = makeFs();
-        await initNewProject({ projectName: "demo-app", feStack: "angular", projectsRoot: "/tmp", fs });
-        const env = Array.from(fs.files.entries()).find(([p]) => p.endsWith("environments/environment.ts"))?.[1];
-        const api = Array.from(fs.files.entries()).find(([p]) => p.endsWith("api/api.service.ts"))?.[1];
-        expect(env).toContain("apiBase");
-        expect(api).toContain("environment.apiBase");
-    });
-});
-//# sourceMappingURL=fe-scaffold-contents.test.js.map

package/dist/src/scaffold/__tests__/init-new.smoke.spec.d.ts

@@ -1,15 +0,0 @@
-/**
- * Smoke test for initNewProject — real filesystem.
- *
- * Plan 23-01b retired the git-clone fallback: BE scaffold now requires a
- * `bbTemplate` and a working `dotnet` SDK + NuGet feed. The legacy bare-repo
- * smoke variants were removed; we now exercise FE-only scaffolds (no
- * bbTemplate) so the test stays portable across machines without .NET SDK.
- *
- * Gated behind env var MUONROI_SMOKE_INIT_NEW=1 because it writes real files
- * to the OS temp directory.
- *
- * Run locally with:
- *   MUONROI_SMOKE_INIT_NEW=1 bunx vitest run src/scaffold/__tests__/init-new.smoke.spec.ts
- */
-export {};

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

@@ -1,81 +0,0 @@
-/**
- * Smoke test for initNewProject — real filesystem.
- *
- * Plan 23-01b retired the git-clone fallback: BE scaffold now requires a
- * `bbTemplate` and a working `dotnet` SDK + NuGet feed. The legacy bare-repo
- * smoke variants were removed; we now exercise FE-only scaffolds (no
- * bbTemplate) so the test stays portable across machines without .NET SDK.
- *
- * Gated behind env var MUONROI_SMOKE_INIT_NEW=1 because it writes real files
- * to the OS temp directory.
- *
- * Run locally with:
- *   MUONROI_SMOKE_INIT_NEW=1 bunx vitest run src/scaffold/__tests__/init-new.smoke.spec.ts
- */
-import { existsSync } from "node:fs";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { initNewProject } from "../init-new.js";
-const SMOKE_ENABLED = process.env.MUONROI_SMOKE_INIT_NEW === "1";
-describe.skipIf(!SMOKE_ENABLED)("initNewProject smoke — real filesystem", () => {
-    let tmpDir;
-    beforeAll(async () => {
-        // Create a temp workspace.
-        tmpDir = await mkdtemp(path.join(tmpdir(), "muonroi-smoke-"));
-    }, 30_000);
-    afterAll(async () => {
-        if (tmpDir) {
-            await rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-    it("scaffolds a react project with expected file structure (FE-only)", async () => {
-        const projectsRoot = path.join(tmpDir, "projects");
-        const result = await initNewProject({
-            projectName: "smoke-app",
-            feStack: "react",
-            projectsRoot,
-        });
-        // Project dir exists.
-        expect(existsSync(result.projectDir)).toBe(true);
-        // Root package.json present and valid JSON with workspaces.
-        const pkgJson = JSON.parse(await readFile(path.join(result.projectDir, "package.json"), "utf-8"));
-        expect(pkgJson.name).toBe("smoke-app");
-        expect(pkgJson.workspaces).toContain("client");
-        expect(pkgJson.workspaces).toContain("server");
-        // Server directory created (empty placeholder when no bbTemplate).
-        expect(existsSync(path.join(result.projectDir, "server"))).toBe(true);
-        // Client files exist.
-        expect(existsSync(path.join(result.projectDir, "client", "src", "main.tsx"))).toBe(true);
-        expect(existsSync(path.join(result.projectDir, "client", "package.json"))).toBe(true);
-        expect(existsSync(path.join(result.projectDir, "client", "vite.config.ts"))).toBe(true);
-        // main.tsx wires SemanticProvider.
-        const mainTsx = await readFile(path.join(result.projectDir, "client", "src", "main.tsx"), "utf-8");
-        expect(mainTsx).toContain("SemanticProvider");
-        expect(mainTsx).toContain("@muonroi/agent-harness-react");
-    }, 30_000);
-    it("scaffolds an angular project with expected file structure (FE-only)", async () => {
-        const projectsRoot = path.join(tmpDir, "projects-ng");
-        const result = await initNewProject({
-            projectName: "smoke-ng",
-            feStack: "angular",
-            projectsRoot,
-        });
-        expect(existsSync(result.projectDir)).toBe(true);
-        expect(existsSync(path.join(result.projectDir, "client", "src", "app", "app.component.ts"))).toBe(true);
-        const component = await readFile(path.join(result.projectDir, "client", "src", "app", "app.component.ts"), "utf-8");
-        expect(component).toContain("muonroiSemantic");
-    }, 30_000);
-    it("feStack=none produces no client directory", async () => {
-        const projectsRoot = path.join(tmpDir, "projects-none");
-        const result = await initNewProject({
-            projectName: "smoke-be",
-            feStack: "none",
-            projectsRoot,
-        });
-        expect(existsSync(result.projectDir)).toBe(true);
-        expect(existsSync(path.join(result.projectDir, "client"))).toBe(false);
-    }, 30_000);
-});
-//# sourceMappingURL=init-new.smoke.spec.js.map

package/dist/src/scaffold/__tests__/init-new.spec.d.ts

@@ -1,5 +0,0 @@
-/**
- * Unit tests for initNewProject scaffolder.
- * All fs + exec operations are mocked — no real I/O or shell-out.
- */
-export {};