pi-lens 3.2.0 → 3.3.1

package/clients/dispatch/runners/shellcheck.test.js

@@ -0,0 +1,98 @@
+/**
+ * Tests for shellcheck runner
+ */
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+function createMockContext(filePath) {
+    return {
+        filePath,
+        cwd: process.cwd(),
+        kind: "shell",
+        autofix: false,
+        deltaMode: false,
+        baselines: { get: () => [], add: () => { }, save: () => { } },
+        pi: {},
+        hasTool: async () => false,
+        log: () => { },
+    };
+}
+// Helper for safe file cleanup
+function safeUnlink(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    }
+    catch {
+        // Ignore cleanup errors on Windows
+    }
+}
+describe("shellcheck runner", () => {
+    const require = createRequire(import.meta.url);
+    it("should have correct runner definition", async () => {
+        const shellcheckModule = await import("./shellcheck.js");
+        const runner = shellcheckModule.default;
+        expect(runner.id).toBe("shellcheck");
+        expect(runner.appliesTo).toEqual(["shell"]);
+        expect(runner.priority).toBe(20);
+        expect(runner.enabledByDefault).toBe(true);
+        expect(runner.skipTestFiles).toBe(false);
+    });
+    it("should detect shellcheck availability", () => {
+        const { spawnSync } = require("node:child_process");
+        const result = spawnSync("shellcheck", ["--version"], {
+            encoding: "utf-8",
+            timeout: 10000,
+            shell: true,
+        });
+        expect(result.error || result.status !== 0 ? "not available" : "available").toBeTruthy();
+    });
+    it("should detect undefined variable", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `shellcheck_test_${Date.now()}.sh`);
+        fs.writeFileSync(tmpFile, ["#!/bin/bash", "# Test script with issues", 'echo "\$UNDEFINED_VAR"', ""].join("\n"));
+        try {
+            const shellcheckModule = await import("./shellcheck.js");
+            const runner = shellcheckModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            if (result.status !== "skipped") {
+                expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+                expect(result.diagnostics.some((d) => d.tool === "shellcheck" &&
+                    (d.message.includes("undefined") ||
+                        d.message.includes("SC2154")))).toBe(true);
+            }
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should pass clean shell scripts", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `shellcheck_ok_${Date.now()}.sh`);
+        fs.writeFileSync(tmpFile, [
+            "#!/bin/bash",
+            "# Clean shell script",
+            "set -euo pipefail",
+            "",
+            "main() {",
+            '    local name="\${1:-world}"',
+            '    echo "Hello, \${name}!"',
+            "}",
+            "",
+            'main "\$@"',
+            "",
+        ].join("\n"));
+        try {
+            const shellcheckModule = await import("./shellcheck.js");
+            const runner = shellcheckModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            if (result.status !== "skipped") {
+                expect(result.diagnostics.length).toBe(0);
+                expect(result.status).toBe("succeeded");
+            }
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+});

package/clients/dispatch/runners/spellcheck.test.js

@@ -0,0 +1,158 @@
+/**
+ * Tests for spellcheck runner (typos-cli)
+ */
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+function createMockContext(filePath) {
+    return {
+        filePath,
+        cwd: process.cwd(),
+        kind: "markdown",
+        autofix: false,
+        deltaMode: false,
+        baselines: { get: () => [], add: () => { }, save: () => { } },
+        pi: {},
+        hasTool: async () => false,
+        log: () => { },
+    };
+}
+describe("spellcheck runner", () => {
+    const require = createRequire(import.meta.url);
+    it("should have correct runner definition", async () => {
+        const spellcheckModule = await import("./spellcheck.js");
+        const runner = spellcheckModule.default;
+        expect(runner.id).toBe("spellcheck");
+        expect(runner.appliesTo).toEqual(["markdown"]);
+        expect(runner.priority).toBe(30);
+        expect(runner.enabledByDefault).toBe(true);
+        expect(runner.skipTestFiles).toBe(false); // Check docs in test files too
+    });
+    it("should detect typos-cli availability", () => {
+        const { spawnSync } = require("node:child_process");
+        const result = spawnSync("typos", ["--version"], {
+            encoding: "utf-8",
+            timeout: 10000,
+            shell: true,
+        });
+        expect(result.error || result.status !== 0 ? "not available" : "available").toBeTruthy(); // May or may not be installed
+    });
+    it("should detect typos in markdown content", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `spellcheck_test_${Date.now()}.md`);
+        fs.writeFileSync(tmpFile, `# README
+
+This is a documnet about recieving data.
+The seperation of concerns is important.
+`);
+        try {
+            const spellcheckModule = await import("./spellcheck.js");
+            const runner = spellcheckModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            // If typos-cli is installed, should detect typos
+            // If not installed, will be skipped
+            if (result.status !== "skipped") {
+                // Should detect at least "documnet" and "recieving"
+                expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+                expect(result.diagnostics.some((d) => d.tool === "typos" &&
+                    (d.message.includes("documnet") ||
+                        d.message.includes("recieving") ||
+                        d.message.includes("seperation")))).toBe(true);
+            }
+        }
+        finally {
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+    it("should suggest corrections for typos", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `spellcheck_fix_${Date.now()}.md`);
+        fs.writeFileSync(tmpFile, `# Test
+
+This is a recieving test.
+`);
+        try {
+            const spellcheckModule = await import("./spellcheck.js");
+            const runner = spellcheckModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            if (result.status !== "skipped" && result.diagnostics.length > 0) {
+                // Should have fix suggestions
+                const fixableDiags = result.diagnostics.filter((d) => d.fixable);
+                expect(fixableDiags.length).toBeGreaterThanOrEqual(1);
+                expect(fixableDiags.some((d) => d.fixSuggestion?.toLowerCase().includes("receive"))).toBe(true);
+            }
+        }
+        finally {
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+    it("should pass clean markdown files", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `spellcheck_ok_${Date.now()}.md`);
+        fs.writeFileSync(tmpFile, `# Clean README
+
+This is a correct document about receiving data.
+The separation of concerns is important.
+All spelling is proper in this file.
+`);
+        try {
+            const spellcheckModule = await import("./spellcheck.js");
+            const runner = spellcheckModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            if (result.status !== "skipped") {
+                // Should have no typos
+                expect(result.diagnostics.length).toBe(0);
+                expect(result.status).toBe("succeeded");
+            }
+        }
+        finally {
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+    it("should handle JSON parse errors gracefully", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `spellcheck_json_${Date.now()}.md`);
+        fs.writeFileSync(tmpFile, `# Test\n\nSimple file.`);
+        try {
+            const spellcheckModule = await import("./spellcheck.js");
+            const runner = spellcheckModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            // Should not crash on JSON parse issues
+            expect(["succeeded", "failed", "skipped"]).toContain(result.status);
+        }
+        finally {
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+    it("should skip when typos-cli is not available", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `spellcheck_skip_${Date.now()}.md`);
+        fs.writeFileSync(tmpFile, `# Test\n\nContent with typo: recieve.`);
+        try {
+            const spellcheckModule = await import("./spellcheck.js");
+            const runner = spellcheckModule.default;
+            // Check if typos is available
+            const { spawnSync } = require("node:child_process");
+            const checkResult = spawnSync("typos", ["--version"], {
+                encoding: "utf-8",
+                timeout: 5000,
+                shell: true,
+            });
+            const isAvailable = !checkResult.error && checkResult.status === 0;
+            const result = await runner.run(createMockContext(tmpFile));
+            if (!isAvailable) {
+                expect(result.status).toBe("skipped");
+                expect(result.diagnostics).toHaveLength(0);
+            }
+        }
+        finally {
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+});

package/clients/dispatch/utils/format-utils.js

@@ -1,10 +1,5 @@
 /**
- * Shared formatting utilities for dispatch system
- *
- * Consolidated from:
- * - clients/dispatch/dispatcher.ts
- * - clients/dispatch/bus-dispatcher.ts
- * - clients/services/effect-integration.ts
+ * Shared formatting utilities for the dispatch system.
  */
 export const EMOJI = {
     blocking: "🔴",

package/clients/dispatch/utils/format-utils.ts

@@ -1,10 +1,5 @@
 /**
- * Shared formatting utilities for dispatch system
- * 
- * Consolidated from:
- * - clients/dispatch/dispatcher.ts
- * - clients/dispatch/bus-dispatcher.ts
- * - clients/services/effect-integration.ts
+ * Shared formatting utilities for the dispatch system.
  */
 
 import type { Diagnostic, OutputSemantic } from "../types.js";

package/clients/dogfood.test.js

@@ -0,0 +1,201 @@
+/**
+ * Meta-test: Run similarity detection on pi-lens codebase
+ *
+ * This is a "dogfood" test - we run the reuse detection on our own code
+ * to see what it finds. Educational and useful for improving the algorithm!
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { glob } from "glob";
+import { beforeAll, describe, expect, it } from "vitest";
+import { buildProjectIndex, findSimilarFunctions, } from "./project-index.js";
+import { calculateSimilarity as calcMatrixSimilarity } from "./state-matrix.js";
+// Find project root by looking for package.json
+async function findProjectRoot(startDir) {
+    let dir = startDir;
+    while (dir !== path.dirname(dir)) {
+        try {
+            await fs.access(path.join(dir, "package.json"));
+            return dir;
+        }
+        catch {
+            dir = path.dirname(dir);
+        }
+    }
+    throw new Error("Could not find project root (no package.json)");
+}
+// Test a known similar pair
+const _SIMILAR_FUNCTIONS = {
+    description: "Extracting similar logic patterns in pi-lens",
+    pairs: [
+        {
+            name: "runners/index.ts pattern",
+            files: [
+                "clients/dispatch/runners/index.ts",
+                "clients/dispatch/runners/architect.ts",
+            ],
+            expected: "High similarity in runner registration patterns",
+        },
+        {
+            name: "Client pattern",
+            files: ["clients/typescript-client.ts", "clients/biome-client.ts"],
+            expected: "Similar client structures",
+        },
+    ],
+};
+describe("🐶 Dogfood Test: Similarity on pi-lens codebase", () => {
+    let index;
+    let projectRoot;
+    beforeAll(async () => {
+        // Find project root
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        projectRoot = await findProjectRoot(__dirname);
+        // Build index of the entire codebase
+        console.log("\n🏗️  Building index of pi-lens codebase...");
+        console.log(`   Project root: ${projectRoot}`);
+        const files = await glob("clients/**/*.ts", {
+            cwd: projectRoot,
+            ignore: ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**"],
+        });
+        console.log(`   Found ${files.length} source files`);
+        const absoluteFiles = files.map((f) => path.join(projectRoot, f));
+        index = await buildProjectIndex(projectRoot, absoluteFiles);
+        console.log(`   Indexed ${index.entries.size} functions`);
+        // Show some indexed functions
+        const sample = Array.from(index.entries.values()).slice(0, 5);
+        console.log("\n📋 Sample indexed functions:");
+        sample.forEach((e, i) => {
+            console.log(`   ${i + 1}. ${e.id} (${e.transitionCount} transitions)`);
+        });
+    }, 30000); // 30s timeout for indexing
+    describe("Index validation", () => {
+        it("should have indexed functions", () => {
+            expect(index.entries.size).toBeGreaterThan(0);
+            console.log(`\n✅ Indexed ${index.entries.size} functions`);
+        });
+        it("should have functions with >20 transitions", () => {
+            const complex = Array.from(index.entries.values()).filter((e) => e.transitionCount >= 20);
+            expect(complex.length).toBeGreaterThan(0);
+            console.log(`\n✅ ${complex.length} functions pass complexity guardrail`);
+        });
+    });
+    describe("Find similar functions in our own codebase", () => {
+        it("should find similar patterns among runners", async () => {
+            // Find runner files
+            const runnerEntries = Array.from(index.entries.values()).filter((e) => e.filePath.includes("dispatch/runners/"));
+            console.log(`\n🔍 Testing ${runnerEntries.length} runner functions`);
+            const similarities = [];
+            // Compare each pair
+            for (let i = 0; i < runnerEntries.length; i++) {
+                for (let j = i + 1; j < runnerEntries.length; j++) {
+                    const entry1 = runnerEntries[i];
+                    const entry2 = runnerEntries[j];
+                    // Skip if same file
+                    if (entry1.filePath === entry2.filePath)
+                        continue;
+                    const sim = calcMatrixSimilarity(entry1.matrix, entry2.matrix);
+                    if (sim >= 0.75) {
+                        similarities.push({
+                            func1: entry1.id,
+                            func2: entry2.id,
+                            similarity: sim,
+                        });
+                    }
+                }
+            }
+            // Sort by similarity
+            similarities.sort((a, b) => b.similarity - a.similarity);
+            console.log(`\n📊 Found ${similarities.length} similar pairs (>75%):`);
+            similarities.slice(0, 5).forEach((s, i) => {
+                console.log(`   ${i + 1}. ${s.func1} ↔ ${s.func2}`);
+                console.log(`      Similarity: ${(s.similarity * 100).toFixed(1)}%`);
+            });
+            // Log findings but don't fail - this is exploratory
+            expect(similarities.length).toBeGreaterThanOrEqual(0);
+        });
+        it("should find similar client patterns", async () => {
+            const clientEntries = Array.from(index.entries.values()).filter((e) => e.filePath.includes("clients/") &&
+                e.filePath.includes("-client.ts") &&
+                !e.filePath.includes("test"));
+            console.log(`\n🔍 Testing ${clientEntries.length} client functions`);
+            const similarities = [];
+            for (let i = 0; i < clientEntries.length; i++) {
+                for (let j = i + 1; j < clientEntries.length; j++) {
+                    const entry1 = clientEntries[i];
+                    const entry2 = clientEntries[j];
+                    if (entry1.filePath === entry2.filePath)
+                        continue;
+                    const sim = calcMatrixSimilarity(entry1.matrix, entry2.matrix);
+                    if (sim >= 0.75) {
+                        similarities.push({
+                            func1: entry1.id,
+                            func2: entry2.id,
+                            similarity: sim,
+                        });
+                    }
+                }
+            }
+            similarities.sort((a, b) => b.similarity - a.similarity);
+            console.log(`\n📊 Found ${similarities.length} similar client patterns (>75%):`);
+            similarities.slice(0, 3).forEach((s, i) => {
+                console.log(`   ${i + 1}. ${s.func1} ↔ ${s.func2}`);
+                console.log(`      Similarity: ${(s.similarity * 100).toFixed(1)}%`);
+            });
+            expect(similarities.length).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe("Find potential refactor opportunities", () => {
+        it("should identify duplicate utility functions", () => {
+            // Look for functions with very high similarity (>90%)
+            const entries = Array.from(index.entries.values());
+            const seenPairs = new Set(); // Deduplicate A→B and B→A
+            const duplicates = [];
+            for (const entry of entries) {
+                const matches = findSimilarFunctions(entry.matrix, index, 0.9, 3);
+                for (const match of matches) {
+                    if (match.targetId === entry.id)
+                        continue;
+                    // Canonical pair key (sorted to avoid A,B and B,A)
+                    const pairKey = [entry.id, match.targetId].sort().join("::");
+                    if (seenPairs.has(pairKey))
+                        continue;
+                    seenPairs.add(pairKey);
+                    duplicates.push({
+                        func: entry.id,
+                        similarTo: match.targetId,
+                        similarity: match.similarity,
+                    });
+                }
+            }
+            console.log(`\n🎯 Found ${duplicates.length} unique potential duplicates (>90%):`);
+            duplicates.slice(0, 5).forEach((d, i) => {
+                console.log(`   ${i + 1}. ${d.func}`);
+                console.log(`      Similar to: ${d.similarTo}`);
+                console.log(`      Match: ${(d.similarity * 100).toFixed(1)}%`);
+            });
+            // This is informational - we don't assert on it
+            expect(true).toBe(true);
+        });
+    });
+    describe("Complexity distribution", () => {
+        it("should show transition count distribution", () => {
+            const entries = Array.from(index.entries.values());
+            const transitionCounts = entries.map((e) => e.transitionCount);
+            const avg = transitionCounts.reduce((a, b) => a + b, 0) / transitionCounts.length;
+            const min = Math.min(...transitionCounts);
+            const max = Math.max(...transitionCounts);
+            const belowThreshold = transitionCounts.filter((c) => c < 20).length;
+            const aboveThreshold = transitionCounts.filter((c) => c >= 20).length;
+            console.log("\n📊 Complexity Distribution:");
+            console.log(`   Total functions: ${entries.length}`);
+            console.log(`   Below threshold (<20): ${belowThreshold}`);
+            console.log(`   Above threshold (≥20): ${aboveThreshold}`);
+            console.log(`   Min transitions: ${min}`);
+            console.log(`   Max transitions: ${max}`);
+            console.log(`   Average: ${avg.toFixed(1)}`);
+            // Most functions should pass the guardrail
+            expect(aboveThreshold).toBeGreaterThan(0);
+        });
+    });
+});

package/clients/file-kinds.test.js

@@ -0,0 +1,169 @@
+/**
+ * Tests for file-kinds.ts
+ * Centralized file type detection
+ */
+import { describe, expect, it } from "vitest";
+import { detectFileKind, getExtensionsForKind, getFileKindLabel, getLanguageId, isCodeKind, isConfigKind, isFileKind, isScannableFile, } from "./file-kinds.js";
+describe("detectFileKind", () => {
+    it("should detect JavaScript/TypeScript files", () => {
+        expect(detectFileKind("src/app.ts")).toBe("jsts");
+        expect(detectFileKind("src/app.tsx")).toBe("jsts");
+        expect(detectFileKind("src/app.js")).toBe("jsts");
+        expect(detectFileKind("src/app.jsx")).toBe("jsts");
+        expect(detectFileKind("src/app.mjs")).toBe("jsts");
+        expect(detectFileKind("src/app.cjs")).toBe("jsts");
+    });
+    it("should detect Python files", () => {
+        expect(detectFileKind("app.py")).toBe("python");
+        expect(detectFileKind("tests/test_app.py")).toBe("python");
+    });
+    it("should detect Go files", () => {
+        expect(detectFileKind("main.go")).toBe("go");
+        expect(detectFileKind("pkg/utils.go")).toBe("go");
+    });
+    it("should detect Rust files", () => {
+        expect(detectFileKind("main.rs")).toBe("rust");
+        expect(detectFileKind("lib/app.rs")).toBe("rust");
+    });
+    it("should detect C++ files", () => {
+        expect(detectFileKind("main.cpp")).toBe("cxx");
+        expect(detectFileKind("header.hpp")).toBe("cxx");
+        expect(detectFileKind("file.cc")).toBe("cxx");
+        expect(detectFileKind("file.hxx")).toBe("cxx");
+    });
+    it("should detect CMake files", () => {
+        expect(detectFileKind("CMakeLists.txt")).toBe("cmake");
+        expect(detectFileKind("build.cmake")).toBe("cmake");
+    });
+    it("should detect Shell files", () => {
+        expect(detectFileKind("script.sh")).toBe("shell");
+        expect(detectFileKind("script.bash")).toBe("shell");
+        expect(detectFileKind("Makefile")).toBe("shell");
+    });
+    it("should detect JSON files", () => {
+        expect(detectFileKind("config.json")).toBe("json");
+        expect(detectFileKind("package.json")).toBe("json");
+    });
+    it("should detect Markdown files", () => {
+        expect(detectFileKind("README.md")).toBe("markdown");
+        expect(detectFileKind("docs/guide.mdx")).toBe("markdown");
+    });
+    it("should detect CSS files", () => {
+        expect(detectFileKind("style.css")).toBe("css");
+        expect(detectFileKind("style.scss")).toBe("css");
+        expect(detectFileKind("style.less")).toBe("css");
+    });
+    it("should detect YAML files", () => {
+        expect(detectFileKind("config.yaml")).toBe("yaml");
+        expect(detectFileKind("config.yml")).toBe("yaml");
+    });
+    it("should return undefined for unknown extensions", () => {
+        expect(detectFileKind("file.xyz")).toBeUndefined();
+        expect(detectFileKind("file")).toBeUndefined();
+    });
+    it("should handle case-insensitive extensions", () => {
+        expect(detectFileKind("file.TS")).toBe("jsts");
+        expect(detectFileKind("file.PY")).toBe("python");
+    });
+    it("should handle paths with special characters", () => {
+        expect(detectFileKind("/path/to/file.ts")).toBe("jsts");
+        expect(detectFileKind("C:\\path\\to\\file.py")).toBe("python");
+    });
+});
+describe("isFileKind", () => {
+    it("should check single file kind", () => {
+        expect(isFileKind("app.ts", "jsts")).toBe(true);
+        expect(isFileKind("app.py", "jsts")).toBe(false);
+    });
+    it("should check multiple file kinds", () => {
+        expect(isFileKind("app.ts", ["jsts", "python"])).toBe(true);
+        expect(isFileKind("app.py", ["jsts", "python"])).toBe(true);
+        expect(isFileKind("app.go", ["jsts", "python"])).toBe(false);
+    });
+    it("should return false for undefined file kind", () => {
+        expect(isFileKind("file.xyz", "jsts")).toBe(false);
+        expect(isFileKind("file.xyz", ["jsts", "python"])).toBe(false);
+    });
+});
+describe("isCodeKind", () => {
+    it("should identify code file kinds", () => {
+        expect(isCodeKind("jsts")).toBe(true);
+        expect(isCodeKind("python")).toBe(true);
+        expect(isCodeKind("go")).toBe(true);
+        expect(isCodeKind("rust")).toBe(true);
+        expect(isCodeKind("cxx")).toBe(true);
+        expect(isCodeKind("shell")).toBe(true);
+    });
+    it("should reject non-code file kinds", () => {
+        expect(isCodeKind("json")).toBe(false);
+        expect(isCodeKind("markdown")).toBe(false);
+        expect(isCodeKind("css")).toBe(false);
+    });
+});
+describe("isConfigKind", () => {
+    it("should identify config file kinds", () => {
+        expect(isConfigKind("json")).toBe(true);
+        expect(isConfigKind("yaml")).toBe(true);
+        expect(isConfigKind("markdown")).toBe(true);
+        expect(isConfigKind("css")).toBe(true);
+    });
+    it("should reject non-config file kinds", () => {
+        expect(isConfigKind("jsts")).toBe(false);
+        expect(isConfigKind("python")).toBe(false);
+        expect(isConfigKind("go")).toBe(false);
+    });
+});
+describe("isScannableFile", () => {
+    it("should return true for code files", () => {
+        expect(isScannableFile("app.ts")).toBe(true);
+        expect(isScannableFile("app.py")).toBe(true);
+    });
+    it("should return true for config files", () => {
+        expect(isScannableFile("config.json")).toBe(true);
+        expect(isScannableFile("README.md")).toBe(true);
+    });
+    it("should return false for test files", () => {
+        expect(isScannableFile("app.test.ts")).toBe(false);
+        expect(isScannableFile("app.spec.ts")).toBe(false);
+        expect(isScannableFile("test-app.ts")).toBe(false);
+    });
+    it("should return false for unknown extensions", () => {
+        expect(isScannableFile("file.xyz")).toBe(false);
+    });
+});
+describe("getLanguageId", () => {
+    it("should return correct language IDs", () => {
+        expect(getLanguageId("jsts")).toBe("typescript");
+        expect(getLanguageId("python")).toBe("python");
+        expect(getLanguageId("go")).toBe("go");
+        expect(getLanguageId("rust")).toBe("rust");
+        expect(getLanguageId("cxx")).toBe("cpp");
+        expect(getLanguageId("json")).toBe("json");
+    });
+    it("should return plaintext for unknown kinds", () => {
+        expect(getLanguageId("unknown")).toBe("plaintext");
+    });
+});
+describe("getExtensionsForKind", () => {
+    it("should return extensions for jsts", () => {
+        const exts = getExtensionsForKind("jsts");
+        expect(exts).toContain(".ts");
+        expect(exts).toContain(".tsx");
+        expect(exts).toContain(".js");
+        expect(exts).toContain(".jsx");
+    });
+    it("should return extensions for python", () => {
+        const exts = getExtensionsForKind("python");
+        expect(exts).toEqual([".py"]);
+    });
+});
+describe("getFileKindLabel", () => {
+    it("should return human-readable labels", () => {
+        expect(getFileKindLabel("jsts")).toBe("JavaScript/TypeScript");
+        expect(getFileKindLabel("python")).toBe("Python");
+        expect(getFileKindLabel("cxx")).toBe("C/C++");
+    });
+    it("should return kind as fallback", () => {
+        expect(getFileKindLabel("unknown")).toBe("unknown");
+    });
+});

package/clients/formatters.js

@@ -459,7 +459,7 @@ export async function formatFile(filePath, formatter) {
             }
         }
         // Run formatter
-        const result = safeSpawn(cmd[0], cmd.slice(1), { timeout: 15000 });
+        const result = safeSpawn(cmd[0], cmd.slice(1), { timeout: 15000, cwd });
         if (result.error) {
             return {
                 success: false,