muonroi-cli 1.8.0 → 1.8.3

package/dist/src/lsp/manager.test.js

@@ -1,155 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { createWorkspaceLspManager } from "./manager.js";
-const BASE_SETTINGS = {
-    enabled: true,
-    tool: true,
-    autoInstall: false,
-    startupTimeoutMs: 5_000,
-    requestTimeoutMs: 5_000,
-    diagnosticsDebounceMs: 0,
-    builtins: {
-        typescript: {
-            enabled: false,
-        },
-    },
-    servers: [
-        {
-            id: "fake-ts",
-            command: "fake-lsp",
-            extensions: [".ts"],
-            languageIds: {
-                ".ts": "typescript",
-            },
-            rootMarkers: [".git"],
-        },
-    ],
-};
-const tempDirs = [];
-afterEach(async () => {
-    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 })));
-});
-describe("createWorkspaceLspManager", () => {
-    it("routes queries through the matching LSP client", async () => {
-        const root = await createTempWorkspace();
-        const filePath = path.join(root, "src", "demo.ts");
-        await mkdir(path.dirname(filePath), { recursive: true });
-        await writeFile(filePath, "const demo = 1;\n");
-        const sendRequest = vi.fn(async (method, params) => {
-            expect(method).toBe("textDocument/definition");
-            expect(params).toMatchObject({
-                position: {
-                    line: 4,
-                    character: 2,
-                },
-            });
-            return [{ uri: "file:///demo.ts", range: { start: { line: 1, character: 0 }, end: { line: 1, character: 4 } } }];
-        });
-        const client = createFakeClient({ sendRequest });
-        const manager = createWorkspaceLspManager(root, BASE_SETTINGS, {
-            createClient: async () => client,
-        });
-        const result = await manager.query({
-            operation: "goToDefinition",
-            filePath,
-            line: 5,
-            character: 3,
-        });
-        expect(result.success).toBe(true);
-        expect(result.output).toContain("file:///demo.ts");
-        expect(client.openOrChangeFile).toHaveBeenCalledWith(filePath, "typescript", "const demo = 1;\n");
-        expect(client.waitForDiagnostics).toHaveBeenCalledWith(filePath, undefined);
-        await manager.close();
-        expect(client.stop).toHaveBeenCalled();
-    });
-    it("returns diagnostics after syncing a saved file", async () => {
-        const root = await createTempWorkspace();
-        const filePath = path.join(root, "demo.ts");
-        const diagnostics = [
-            {
-                filePath,
-                serverId: "fake-ts",
-                diagnostics: [
-                    {
-                        message: "Type error",
-                        severity: 1,
-                        range: {
-                            start: { line: 0, character: 0 },
-                            end: { line: 0, character: 4 },
-                        },
-                    },
-                ],
-            },
-        ];
-        const client = createFakeClient({
-            diagnostics: diagnostics[0].diagnostics,
-        });
-        const manager = createWorkspaceLspManager(root, BASE_SETTINGS, {
-            createClient: async () => client,
-        });
-        const result = await manager.syncFile(filePath, "const broken = true;\n", true, true);
-        expect(result).toEqual(diagnostics);
-        expect(client.saveFile).toHaveBeenCalledWith(filePath);
-        expect(client.waitForDiagnostics).toHaveBeenCalledWith(filePath, undefined);
-        await manager.close();
-    });
-    it("times out a hanging request without dropping the client", async () => {
-        const root = await createTempWorkspace();
-        const filePath = path.join(root, "src", "demo.ts");
-        await mkdir(path.dirname(filePath), { recursive: true });
-        await writeFile(filePath, "const demo = 1;\n");
-        // sendRequest never resolves — simulates a server still loading its workspace.
-        const client = createFakeClient({ sendRequest: () => new Promise(() => { }) });
-        const manager = createWorkspaceLspManager(root, { ...BASE_SETTINGS, requestTimeoutMs: 50 }, {
-            createClient: async () => client,
-        });
-        const result = await manager.query({
-            operation: "documentSymbol",
-            filePath,
-        });
-        // Degrades gracefully instead of hanging forever.
-        expect(result.success).toBe(true);
-        expect(result.output).toContain("No results found");
-        // Client is retained (not dropped) so a retry hits the warmed-up server.
-        await manager.close();
-        expect(client.stop).toHaveBeenCalled();
-    });
-    it("reports when no matching server exists", async () => {
-        const root = await createTempWorkspace();
-        const filePath = path.join(root, "demo.rb");
-        await writeFile(filePath, "puts 'hello'\n");
-        const manager = createWorkspaceLspManager(root, { ...BASE_SETTINGS, servers: [] });
-        const result = await manager.query({
-            operation: "hover",
-            filePath,
-            line: 1,
-            character: 1,
-        });
-        expect(result.success).toBe(false);
-        expect(result.output).toContain("No LSP server available");
-        await manager.close();
-    });
-});
-async function createTempWorkspace() {
-    const root = await mkdtemp(path.join(os.tmpdir(), "muonroi-lsp-manager-"));
-    tempDirs.push(root);
-    await mkdir(path.join(root, ".git"), { recursive: true });
-    return root;
-}
-function createFakeClient(input) {
-    const diagnostics = input.diagnostics ?? [];
-    return {
-        serverId: "fake-ts",
-        root: "/tmp",
-        openOrChangeFile: vi.fn(async () => { }),
-        saveFile: vi.fn(async () => { }),
-        closeFile: vi.fn(async () => { }),
-        sendRequest: (async (method, params) => (input.sendRequest ? await input.sendRequest(method, params) : [])),
-        waitForDiagnostics: vi.fn(async () => diagnostics),
-        getDiagnostics: vi.fn(() => diagnostics),
-        stop: vi.fn(async () => { }),
-    };
-}
-//# sourceMappingURL=manager.test.js.map

package/dist/src/lsp/npm-cache.test.d.ts

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

package/dist/src/lsp/npm-cache.test.js

@@ -1,53 +0,0 @@
-import { mkdir, rm, writeFile } from "fs/promises";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { lspNpmWhich } from "./npm-cache.js";
-const tempDirs = [];
-afterEach(async () => {
-    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 })));
-});
-describe("lspNpmWhich", () => {
-    it("resolves a single binary from a pre-populated cache", async () => {
-        const dir = await createFakePackageCache("fake-server", { "fake-server": "lib/cli.js" });
-        const result = await lspNpmWhich("fake-server");
-        expect(result).toBe(path.join(dir, "node_modules", ".bin", "fake-server"));
-    });
-    it("resolves the correct binary from a multi-binary package", async () => {
-        const dir = await createFakePackageCache("multi-bin", {
-            "multi-bin": "lib/main.js",
-            "multi-bin-helper": "lib/helper.js",
-        });
-        const result = await lspNpmWhich("multi-bin");
-        expect(result).toBe(path.join(dir, "node_modules", ".bin", "multi-bin"));
-    });
-    it("returns null when the package cannot be installed", async () => {
-        const result = await lspNpmWhich("@nonexistent-scope/totally-fake-package-that-does-not-exist-12345");
-        expect(result).toBeNull();
-    });
-});
-async function createFakePackageCache(pkg, binEntries) {
-    const cacheRoot = path.join(os.homedir(), ".muonroi-cli", "cache", "lsp", pkg);
-    tempDirs.push(cacheRoot);
-    const binDir = path.join(cacheRoot, "node_modules", ".bin");
-    const pkgDir = path.join(cacheRoot, "node_modules", pkg);
-    await mkdir(binDir, { recursive: true });
-    await mkdir(pkgDir, { recursive: true });
-    for (const [name, target] of Object.entries(binEntries)) {
-        const targetPath = path.join(pkgDir, target);
-        await mkdir(path.dirname(targetPath), { recursive: true });
-        await writeFile(targetPath, "#!/usr/bin/env node\n", { mode: 0o755 });
-        const linkPath = path.join(binDir, name);
-        const { symlink } = await import("fs/promises");
-        await symlink(path.relative(binDir, targetPath), linkPath).catch(() => {
-            // Fallback: write a stub file if symlinks fail (Windows)
-            return writeFile(linkPath, `#!/bin/sh\nnode "${targetPath}" "$@"\n`, { mode: 0o755 });
-        });
-    }
-    await writeFile(path.join(pkgDir, "package.json"), JSON.stringify({
-        name: pkg,
-        bin: Object.keys(binEntries).length === 1 ? Object.values(binEntries)[0] : binEntries,
-    }));
-    return cacheRoot;
-}
-//# sourceMappingURL=npm-cache.test.js.map

package/dist/src/lsp/smoke.test.d.ts

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

package/dist/src/lsp/smoke.test.js

@@ -1,56 +0,0 @@
-import { execSync } from "child_process";
-import { mkdirSync, rmSync, writeFileSync } from "fs";
-import os from "os";
-import path from "path";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { createLspClientSession } from "./client.js";
-let tsServerAvailable = false;
-let tmpDir = "";
-beforeAll(() => {
-    // Check if typescript-language-server AND typescript are both available
-    try {
-        execSync("bunx typescript-language-server --version", { timeout: 5000, stdio: "pipe" });
-        execSync("bunx tsc --version", { timeout: 5000, stdio: "pipe" });
-        tsServerAvailable = true;
-    }
-    catch {
-        tsServerAvailable = false;
-    }
-    // Create temp directory with a minimal TypeScript project
-    tmpDir = path.join(os.tmpdir(), `lsp-smoke-${Date.now()}`);
-    mkdirSync(tmpDir, { recursive: true });
-    writeFileSync(path.join(tmpDir, "tsconfig.json"), JSON.stringify({ compilerOptions: { strict: true } }, null, 2), "utf8");
-    writeFileSync(path.join(tmpDir, "test.ts"), "const x: number = 1;\n", "utf8");
-});
-afterAll(() => {
-    try {
-        rmSync(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    }
-    catch {
-        // Best-effort cleanup
-    }
-});
-describe("LSP smoke test — createLspClientSession", () => {
-    it.skipIf(!tsServerAvailable || !!process.env.CI)("initializes LSP session with typescript-language-server", { timeout: 30000 }, async () => {
-        const session = await createLspClientSession({
-            serverId: "ts-smoke",
-            root: tmpDir,
-            launch: { command: "bunx", args: ["typescript-language-server", "--stdio"] },
-            startupTimeoutMs: 15000,
-            diagnosticsDebounceMs: 500,
-        });
-        expect(session.serverId).toBe("ts-smoke");
-        await session.openOrChangeFile(path.join(tmpDir, "test.ts"), "typescript", "const x: number = 1;");
-        await session.stop();
-    });
-    it("createLspClientSession rejects for non-existent command", { timeout: 10000 }, async () => {
-        await expect(createLspClientSession({
-            serverId: "bad",
-            root: os.tmpdir(),
-            launch: { command: "nonexistent-lsp-binary-xyz" },
-            startupTimeoutMs: 2000,
-            diagnosticsDebounceMs: 500,
-        })).rejects.toThrow();
-    });
-});
-//# sourceMappingURL=smoke.test.js.map

package/dist/src/maintain/__tests__/codebase-intel.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * codebase-intel.test.ts — Unit tests for gatherCodebaseIntel + helpers.
- * Uses tmpdir for all fs operations — never touches the real workspace.
- */
-export {};

package/dist/src/maintain/__tests__/codebase-intel.test.js

@@ -1,237 +0,0 @@
-/**
- * codebase-intel.test.ts — Unit tests for gatherCodebaseIntel + helpers.
- * Uses tmpdir for all fs operations — never touches the real workspace.
- */
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { extractKeywords, gatherCodebaseIntel } from "../codebase-intel.js";
-let tmpDir;
-beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "muonroi-codebase-intel-test-"));
-});
-afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-});
-// ---------------------------------------------------------------------------
-// extractKeywords
-// ---------------------------------------------------------------------------
-describe("extractKeywords", () => {
-    it("strips English stopwords", () => {
-        const kws = extractKeywords("fix the login redirect bug in the auth module");
-        expect(kws).not.toContain("the");
-        expect(kws).not.toContain("in");
-        expect(kws).toContain("login");
-        expect(kws).toContain("redirect");
-        expect(kws).toContain("auth");
-        expect(kws).toContain("module");
-    });
-    it("strips Vietnamese stopwords", () => {
-        const kws = extractKeywords("sửa lỗi không redirect đúng trong module đăng nhập");
-        expect(kws).not.toContain("không");
-        expect(kws).not.toContain("trong");
-        // meaningful words should survive
-        expect(kws.length).toBeGreaterThan(0);
-    });
-    it("drops tokens shorter than 3 chars", () => {
-        const kws = extractKeywords("fix ui db api bug");
-        expect(kws).not.toContain("ui");
-        expect(kws).not.toContain("db");
-        // api is 3 chars — exactly at the threshold, should be kept
-        expect(kws).toContain("api"); // length exactly 3 — not dropped
-        // "fix" is 3 chars — kept (threshold is < 3, so 3 is allowed)
-        expect(kws).toContain("fix");
-    });
-    it("drops pure numbers", () => {
-        const kws = extractKeywords("issue 12345 on line 99 fix");
-        expect(kws).not.toContain("12345");
-        expect(kws).not.toContain("99");
-    });
-    it("deduplicates tokens", () => {
-        const kws = extractKeywords("login login login redirect login");
-        const loginCount = kws.filter((k) => k === "login").length;
-        expect(loginCount).toBe(1);
-    });
-    it("caps at 10 keywords", () => {
-        // 15 distinct meaningful words
-        const text = "authentication redirect session cookie token header payload signature expiry validation middleware interceptor pipeline router controller";
-        const kws = extractKeywords(text);
-        expect(kws.length).toBeLessThanOrEqual(10);
-    });
-    it("sorts by length descending for determinism (longer first)", () => {
-        const kws = extractKeywords("authentication redirect session");
-        // "authentication" is longest — should come first
-        expect(kws[0]).toBe("authentication");
-    });
-});
-// ---------------------------------------------------------------------------
-// gatherCodebaseIntel — candidate ranking
-// ---------------------------------------------------------------------------
-describe("gatherCodebaseIntel — candidate ranking", () => {
-    it("prefers filename match over body match", async () => {
-        // File whose name matches the keyword
-        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
-        await fs.writeFile(path.join(tmpDir, "src", "auth.ts"), `export function noop() {}`, // no keyword in body
-        "utf8");
-        // File with keyword only in body (not in name)
-        await fs.writeFile(path.join(tmpDir, "src", "utils.ts"), `// auth logic here\nexport function auth() {}\n// auth auth auth auth auth auth auth`, // many body hits
-        "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix auth bug", description: "the auth module is broken", kind: "bug" },
-        });
-        const paths = intel.candidateFiles.map((c) => c.path);
-        expect(paths[0]).toContain("auth.ts"); // filename match wins
-    });
-    it("includes path-based match when keyword appears in directory name", async () => {
-        await fs.mkdir(path.join(tmpDir, "src", "auth"), { recursive: true });
-        await fs.writeFile(path.join(tmpDir, "src", "auth", "handler.ts"), `export function handle() {}`, "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix auth handler", description: "fix auth", kind: "bug" },
-        });
-        const paths = intel.candidateFiles.map((c) => c.path);
-        expect(paths.some((p) => p.includes("auth/handler.ts") || p.includes("auth\\handler.ts"))).toBe(true);
-    });
-    it("matchScore is between 0 and 1", async () => {
-        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
-        await fs.writeFile(path.join(tmpDir, "src", "login.ts"), `// login handler\nexport function login() {}`, "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix login redirect", description: "login page redirects incorrectly", kind: "bug" },
-        });
-        for (const cf of intel.candidateFiles) {
-            expect(cf.matchScore).toBeGreaterThanOrEqual(0);
-            expect(cf.matchScore).toBeLessThanOrEqual(1);
-        }
-    });
-    it("returns empty candidateFiles when keywords produce no matches", async () => {
-        // Only a file with totally unrelated content
-        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
-        await fs.writeFile(path.join(tmpDir, "src", "xyz.ts"), "export const x = 1;", "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "qwertyuiop zzz yyy xxx", description: "asdfghjkl", kind: "chore" },
-        });
-        expect(intel.candidateFiles.length).toBe(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// Impact radius
-// ---------------------------------------------------------------------------
-describe("gatherCodebaseIntel — impact radius", () => {
-    it("finds JS/TS files that import a candidate", async () => {
-        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
-        // Candidate file — keyword in name so it scores highest
-        await fs.writeFile(path.join(tmpDir, "src", "auth.ts"), "export function auth() {}", "utf8");
-        // Importer — neutral name, body only contains the import path (which has "auth")
-        // Use maxCandidates:1 so only auth.ts is a candidate and bootstrapper.ts
-        // is therefore eligible for impact radius detection.
-        await fs.writeFile(path.join(tmpDir, "src", "bootstrapper.ts"), `import { auth } ${"from"} './auth';\nexport const boot = auth;`, "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix auth bug", description: "auth module broken", kind: "bug" },
-            maxCandidates: 1, // only auth.ts is a candidate; bootstrapper.ts goes to impact radius
-        });
-        // bootstrapper.ts imports auth.ts via from './auth' — should appear in impact radius
-        expect(intel.impactRadius.some((f) => f.includes("bootstrapper"))).toBe(true);
-        // The candidate itself must not be listed in impactRadius
-        expect(intel.impactRadius.every((f) => !f.includes("auth.ts"))).toBe(true);
-    });
-    it("finds C# files that 'using' a candidate", async () => {
-        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
-        // Candidate — keyword in name
-        await fs.writeFile(path.join(tmpDir, "src", "AuthService.cs"), "public class AuthService {}", "utf8");
-        // Importer — neutral name that won't match any task keyword
-        // Note: must NOT contain "authservice" in its body beyond the using statement
-        // to avoid becoming a candidate itself. The using statement alone scores low
-        // but the file name "Bootstrapper" has no keyword overlap so it won't rank
-        // as a candidate (maxCandidates=1 to ensure only AuthService is candidate).
-        await fs.writeFile(path.join(tmpDir, "src", "Bootstrapper.cs"), `using MyApp.AuthService;\npublic class Bootstrapper {}`, "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix AuthService bug", description: "AuthService crashes on null input", kind: "bug" },
-            maxCandidates: 1, // ensure only AuthService.cs is a candidate
-        });
-        expect(intel.impactRadius.some((f) => f.includes("Bootstrapper"))).toBe(true);
-    });
-});
-// ---------------------------------------------------------------------------
-// Regression tests
-// ---------------------------------------------------------------------------
-describe("gatherCodebaseIntel — regression tests", () => {
-    it("picks up .test.ts files that reference candidate basenames", async () => {
-        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
-        await fs.mkdir(path.join(tmpDir, "tests"), { recursive: true });
-        await fs.writeFile(path.join(tmpDir, "src", "auth.ts"), "export function auth() {}", "utf8");
-        await fs.writeFile(path.join(tmpDir, "tests", "auth.test.ts"), `import { auth } ${"from"} '../src/auth';\nit('works', () => auth());`, "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix auth", description: "auth is broken", kind: "bug" },
-        });
-        expect(intel.regressionTests.some((f) => f.includes("auth.test.ts"))).toBe(true);
-    });
-    it("picks up .spec.ts files", async () => {
-        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
-        await fs.mkdir(path.join(tmpDir, "__tests__"), { recursive: true });
-        await fs.writeFile(path.join(tmpDir, "src", "session.ts"), "export function session() {}", "utf8");
-        await fs.writeFile(path.join(tmpDir, "__tests__", "session.spec.ts"), `describe('session', () => { it('ok', () => session()) });`, "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix session expiry", description: "session does not expire correctly", kind: "bug" },
-        });
-        expect(intel.regressionTests.some((f) => f.includes("session.spec.ts"))).toBe(true);
-    });
-});
-// ---------------------------------------------------------------------------
-// Framework detection
-// ---------------------------------------------------------------------------
-describe("gatherCodebaseIntel — framework detection", () => {
-    it("detects next + node from package.json with next dependency", async () => {
-        await fs.writeFile(path.join(tmpDir, "package.json"), JSON.stringify({ dependencies: { next: "14.0.0", react: "18.0.0" } }), "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix page", description: "page load fails", kind: "bug" },
-        });
-        expect(intel.detectedFrameworks).toContain("next");
-        expect(intel.detectedFrameworks).toContain("node");
-        expect(intel.detectedFrameworks).toContain("react");
-    });
-    it("detects dotnet from .csproj file", async () => {
-        await fs.writeFile(path.join(tmpDir, "MyApp.csproj"), '<Project Sdk="Microsoft.NET.Sdk" />', "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix null ref", description: "null reference exception in service", kind: "bug" },
-        });
-        expect(intel.detectedFrameworks).toContain("dotnet");
-    });
-    it("detects python from requirements.txt", async () => {
-        await fs.writeFile(path.join(tmpDir, "requirements.txt"), "fastapi\nuvicorn\n", "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix endpoint", description: "api endpoint returns 500", kind: "bug" },
-        });
-        expect(intel.detectedFrameworks).toContain("python");
-    });
-    it("detects rust from Cargo.toml", async () => {
-        await fs.writeFile(path.join(tmpDir, "Cargo.toml"), '[package]\nname = "myapp"\n', "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix panic", description: "unwrap panic in main", kind: "bug" },
-        });
-        expect(intel.detectedFrameworks).toContain("rust");
-    });
-    it("returns sorted framework list", async () => {
-        await fs.writeFile(path.join(tmpDir, "package.json"), JSON.stringify({ dependencies: { next: "14.0.0" } }), "utf8");
-        await fs.writeFile(path.join(tmpDir, "requirements.txt"), "flask\n", "utf8");
-        const intel = await gatherCodebaseIntel({
-            cwd: tmpDir,
-            task: { title: "fix something", description: "something is broken", kind: "bug" },
-        });
-        // Result should be sorted
-        const sorted = [...intel.detectedFrameworks].sort();
-        expect(intel.detectedFrameworks).toEqual(sorted);
-    });
-});
-//# sourceMappingURL=codebase-intel.test.js.map

package/dist/src/maintain/__tests__/gh-create-pr.test.d.ts

@@ -1,11 +0,0 @@
-/**
- * gh-create-pr.test.ts — P16 unit tests.
- *
- * Covers:
- *   1. ok=true with URL parsed from gh stdout.
- *   2. gh not installed → ok=false with clear reason.
- *   3. gh not authed → ok=false with auth error message.
- *   4. git push fails → ok=false with push error.
- *   5. branch name with invalid chars → ok=false immediately (no git/gh calls).
- */
-export {};