opencode-conductor-cdd-plugin 1.0.0-beta.13

package/dist/utils/contextAnalysis.test.js

@@ -0,0 +1,307 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { readFile, readdir, stat } from "fs/promises";
+import { execSync } from "child_process";
+import { analyzeProjectContext, parseManifests, analyzeDocs, analyzeGitHistory, analyzeCodeStructure, parseIgnoreFiles, parseCICDConfigs, } from "./contextAnalysis.js";
+vi.mock("fs/promises", () => ({
+    readFile: vi.fn(),
+    readdir: vi.fn(),
+    stat: vi.fn(),
+}));
+vi.mock("child_process", () => ({
+    execSync: vi.fn(),
+}));
+describe("Context Analysis Module", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("parseManifests", () => {
+        it("should parse package.json and extract dependencies", async () => {
+            const mockPackageJson = JSON.stringify({
+                name: "test-project",
+                version: "1.0.0",
+                dependencies: {
+                    react: "^18.0.0",
+                    typescript: "^5.0.0",
+                },
+                devDependencies: {
+                    vitest: "^4.0.0",
+                },
+                scripts: {
+                    test: "vitest",
+                    build: "tsc",
+                },
+            });
+            vi.mocked(readFile).mockResolvedValue(mockPackageJson);
+            vi.mocked(readdir).mockResolvedValue([
+                "package.json",
+            ]);
+            const result = await parseManifests("/test/project");
+            expect(result.manifests).toHaveLength(1);
+            expect(result.manifests[0].type).toBe("package.json");
+            expect(result.manifests[0].dependencies).toContain("react");
+            expect(result.manifests[0].dependencies).toContain("typescript");
+            expect(result.manifests[0].devDependencies).toContain("vitest");
+            expect(result.manifests[0].scripts).toEqual({
+                test: "vitest",
+                build: "tsc",
+            });
+        });
+        it("should parse requirements.txt and extract dependencies", async () => {
+            const mockRequirements = `
+flask==2.0.0
+django>=3.2.0
+pytest
+requests==2.28.0
+`;
+            vi.mocked(readFile).mockResolvedValue(mockRequirements);
+            vi.mocked(readdir).mockResolvedValue([
+                "requirements.txt",
+            ]);
+            const result = await parseManifests("/test/project");
+            expect(result.manifests).toHaveLength(1);
+            expect(result.manifests[0].type).toBe("requirements.txt");
+            expect(result.manifests[0].dependencies).toContain("flask");
+            expect(result.manifests[0].dependencies).toContain("django");
+            expect(result.manifests[0].dependencies).toContain("pytest");
+        });
+        it("should parse Cargo.toml and extract dependencies", async () => {
+            const mockCargoToml = `
+[package]
+name = "test-project"
+version = "0.1.0"
+
+[dependencies]
+tokio = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+`;
+            vi.mocked(readFile).mockResolvedValue(mockCargoToml);
+            vi.mocked(readdir).mockResolvedValue([
+                "Cargo.toml",
+            ]);
+            const result = await parseManifests("/test/project");
+            expect(result.manifests).toHaveLength(1);
+            expect(result.manifests[0].type).toBe("Cargo.toml");
+            expect(result.manifests[0].dependencies).toContain("tokio");
+            expect(result.manifests[0].dependencies).toContain("serde");
+        });
+        it("should handle missing manifest files gracefully", async () => {
+            vi.mocked(readdir).mockResolvedValue([]);
+            const result = await parseManifests("/test/project");
+            expect(result.manifests).toHaveLength(0);
+            expect(result.warnings).toContain("No manifest files found");
+        });
+        it("should handle file read errors gracefully", async () => {
+            vi.mocked(readdir).mockResolvedValue(["package.json"]);
+            vi.mocked(readFile).mockRejectedValue(new Error("Permission denied"));
+            const result = await parseManifests("/test/project");
+            expect(result.manifests).toHaveLength(0);
+            expect(result.warnings.some((w) => w.includes("Failed to read package.json"))).toBe(true);
+        });
+    });
+    describe("analyzeDocs", () => {
+        it("should analyze README.md and extract key information", async () => {
+            const mockReadme = `
+# Test Project
+
+A TypeScript library for testing.
+
+## Features
+- Feature A
+- Feature B
+
+## Installation
+npm install test-project
+
+## Usage
+import { foo } from 'test-project'
+`;
+            vi.mocked(readFile).mockResolvedValue(mockReadme);
+            vi.mocked(readdir).mockResolvedValue(["README.md"]);
+            const result = await analyzeDocs("/test/project");
+            expect(result.docs).toHaveLength(1);
+            expect(result.docs[0].filename).toBe("README.md");
+            expect(result.docs[0].content).toContain("TypeScript library");
+            expect(result.docs[0].content).toContain("Feature A");
+        });
+        it("should sample large files (> 10KB)", async () => {
+            const largeLine = "x".repeat(100);
+            const largeContent = Array(250).fill(largeLine).join("\n") + "\n\nIMPORTANT INFO";
+            vi.mocked(readFile).mockResolvedValue(largeContent);
+            vi.mocked(readdir).mockResolvedValue(["README.md"]);
+            const result = await analyzeDocs("/test/project");
+            expect(result.docs).toHaveLength(1);
+            expect(result.docs[0].content.length).toBeLessThan(largeContent.length);
+            expect(result.warnings).toContain("Large file detected, using sampling");
+        });
+        it("should handle missing README gracefully", async () => {
+            vi.mocked(readdir).mockResolvedValue([]);
+            const result = await analyzeDocs("/test/project");
+            expect(result.docs).toHaveLength(0);
+            expect(result.warnings).toContain("No README found");
+        });
+    });
+    describe("analyzeGitHistory", () => {
+        it("should analyze git commit patterns", async () => {
+            vi.mocked(execSync).mockImplementation(() => `abc1234 feat: add new feature
+def5678 fix: bug fix
+abc9101 chore: update deps
+def1121 test: add tests
+abc3141 feat(auth): implement login
+`);
+            const result = await analyzeGitHistory("/test/project");
+            expect(result.commitCount).toBe(5);
+            expect(result.conventionalCommits).toBeGreaterThan(0);
+            expect(result.patterns).toContain("conventional");
+        });
+        it("should detect non-conventional commit patterns", async () => {
+            vi.mocked(execSync).mockImplementation(() => `abc1234 Add new feature
+def5678 Fix bug
+abc9101 Update README
+def1121 Random commit message
+`);
+            const result = await analyzeGitHistory("/test/project");
+            expect(result.commitCount).toBe(4);
+            expect(result.conventionalCommits).toBe(0);
+            expect(result.patterns).not.toContain("conventional");
+        });
+        it("should handle git command failures gracefully", async () => {
+            vi.mocked(execSync).mockImplementation(() => {
+                throw new Error("Not a git repository");
+            });
+            const result = await analyzeGitHistory("/test/project");
+            expect(result.commitCount).toBe(0);
+            expect(result.warnings.some((w) => w.includes("Not a git repository"))).toBe(true);
+        });
+    });
+    describe("analyzeCodeStructure", () => {
+        it("should analyze directory structure", async () => {
+            vi.mocked(readdir).mockImplementation(async (path) => {
+                if (path === "/test/project") {
+                    return ["src", "tests", "package.json", "README.md", "index.ts", "config.ts"];
+                }
+                if (path === "/test/project/src") {
+                    return ["utils.ts", "components"];
+                }
+                return [];
+            });
+            vi.mocked(stat).mockImplementation(async (path) => {
+                const pathStr = String(path);
+                if (pathStr.endsWith(".ts") || pathStr.endsWith(".md") || pathStr.endsWith(".json")) {
+                    return { isDirectory: () => false, isFile: () => true };
+                }
+                return { isDirectory: () => true, isFile: () => false };
+            });
+            const result = await analyzeCodeStructure("/test/project");
+            expect(result.structure).toContain("src/");
+            expect(result.structure).toContain("tests/");
+            expect(result.fileExtensions).toContain(".ts");
+        });
+        it("should respect max depth of 5", async () => {
+            // This test ensures we don't traverse too deeply
+            let depth = 0;
+            vi.mocked(readdir).mockImplementation(async () => {
+                depth++;
+                if (depth > 5) {
+                    throw new Error("Max depth exceeded");
+                }
+                return depth < 5 ? ["nested"] : [];
+            });
+            const result = await analyzeCodeStructure("/test/project");
+            expect(result.warnings).not.toContain("Max depth exceeded");
+        });
+    });
+    describe("parseIgnoreFiles", () => {
+        it("should parse .gitignore patterns", async () => {
+            const mockGitignore = `
+node_modules/
+dist/
+*.log
+.env
+`;
+            vi.mocked(readFile).mockResolvedValue(mockGitignore);
+            vi.mocked(readdir).mockResolvedValue([".gitignore"]);
+            const result = await parseIgnoreFiles("/test/project");
+            expect(result.patterns).toContain("node_modules/");
+            expect(result.patterns).toContain("dist/");
+            expect(result.patterns).toContain("*.log");
+            expect(result.patterns).toContain(".env");
+        });
+    });
+    describe("parseCICDConfigs", () => {
+        it("should parse GitHub Actions workflow", async () => {
+            const mockWorkflow = `
+name: CI
+on: [push]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - run: npm test
+      - run: npm run build
+`;
+            vi.mocked(readdir).mockImplementation(async (path) => {
+                const pathStr = String(path);
+                if (pathStr.endsWith("workflows")) {
+                    return ["ci.yml"];
+                }
+                return [".github"];
+            });
+            vi.mocked(readFile).mockResolvedValue(mockWorkflow);
+            const result = await parseCICDConfigs("/test/project");
+            expect(result.configs).toHaveLength(1);
+            expect(result.configs[0].type).toBe("github-actions");
+            expect(result.configs[0].commands).toContain("npm test");
+            expect(result.configs[0].commands).toContain("npm run build");
+        });
+    });
+    describe("analyzeProjectContext (Integration)", () => {
+        it("should analyze complete project context with all sources", async () => {
+            // Setup mocks for all analysis functions
+            const mockPackageJson = JSON.stringify({
+                dependencies: { react: "^18.0.0" },
+                scripts: { test: "vitest" },
+            });
+            vi.mocked(readFile).mockImplementation(async (path) => {
+                if (typeof path === "string" && path.endsWith("package.json")) {
+                    return mockPackageJson;
+                }
+                if (typeof path === "string" && path.endsWith("README.md")) {
+                    return "# Test Project\nA React application";
+                }
+                return "";
+            });
+            vi.mocked(readdir).mockResolvedValue([
+                "package.json",
+                "README.md",
+                "src",
+            ]);
+            vi.mocked(execSync).mockReturnValue(Buffer.from("feat: initial commit"));
+            const result = await analyzeProjectContext("/test/project");
+            expect(result.raw.manifests).not.toHaveLength(0);
+            expect(result.raw.docs).not.toHaveLength(0);
+            expect(result.insights.techStack.frameworks).toContainEqual(expect.objectContaining({ name: "react" }));
+            expect(result.meta.filesAnalyzed).toBeGreaterThan(0);
+            expect(result.meta.analysisTimeMs).toBeGreaterThanOrEqual(0);
+        });
+        it("should calculate confidence scores for tech stack", async () => {
+            const mockPackageJson = JSON.stringify({
+                dependencies: {
+                    react: "^18.0.0",
+                    "react-dom": "^18.0.0",
+                },
+            });
+            vi.mocked(readFile).mockResolvedValue(mockPackageJson);
+            vi.mocked(readdir).mockResolvedValue(["package.json"]);
+            const result = await analyzeProjectContext("/test/project");
+            const reactFramework = result.insights.techStack.frameworks.find((f) => f.name === "react");
+            expect(reactFramework).toBeDefined();
+            expect(reactFramework.confidence).toBeGreaterThanOrEqual(0.7);
+        });
+        it("should fallback when no context available", async () => {
+            vi.mocked(readdir).mockResolvedValue([]);
+            const result = await analyzeProjectContext("/test/project");
+            expect(result.meta.warnings).toContain("No manifest files found");
+            expect(result.meta.warnings).toContain("No README found");
+        });
+    });
+});

package/dist/utils/gitNotes.d.ts

@@ -0,0 +1,23 @@
+export interface TaskNoteMetadata {
+    trackId: string;
+    taskName: string;
+    summary: string;
+    filesChanged: string[];
+    reason: string;
+}
+/**
+ * Formats task metadata into a structured note format
+ */
+export declare function formatTaskNote(metadata: TaskNoteMetadata): string;
+/**
+ * Attaches a task note to a specific commit using git notes
+ * @param commitHash - Full or short commit hash
+ * @param metadata - Task metadata to attach
+ */
+export declare function attachTaskNote(commitHash: string, metadata: TaskNoteMetadata): Promise<void>;
+/**
+ * Retrieves the task note attached to a specific commit
+ * @param commitHash - Full or short commit hash
+ * @returns The note content, or empty string if no note exists
+ */
+export declare function getTaskNote(commitHash: string): Promise<string>;

package/dist/utils/gitNotes.js

@@ -0,0 +1,53 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+/**
+ * Formats task metadata into a structured note format
+ */
+export function formatTaskNote(metadata) {
+    const filesSection = metadata.filesChanged.length > 0
+        ? metadata.filesChanged.map(f => `- ${f}`).join("\n")
+        : "(none)";
+    return `Track ID: ${metadata.trackId}
+Task: ${metadata.taskName}
+Summary: ${metadata.summary}
+
+Files Changed:
+${filesSection}
+
+Reason: ${metadata.reason}`;
+}
+/**
+ * Attaches a task note to a specific commit using git notes
+ * @param commitHash - Full or short commit hash
+ * @param metadata - Task metadata to attach
+ */
+export async function attachTaskNote(commitHash, metadata) {
+    const noteContent = formatTaskNote(metadata);
+    try {
+        // Use git notes add to attach the note
+        // The -f flag forces overwriting if a note already exists
+        await execAsync(`git notes add -f -m "${noteContent.replace(/"/g, '\\"')}" ${commitHash}`);
+    }
+    catch (error) {
+        throw new Error(`Failed to attach note to commit ${commitHash}: ${error}`);
+    }
+}
+/**
+ * Retrieves the task note attached to a specific commit
+ * @param commitHash - Full or short commit hash
+ * @returns The note content, or empty string if no note exists
+ */
+export async function getTaskNote(commitHash) {
+    try {
+        const { stdout } = await execAsync(`git notes show ${commitHash}`);
+        return stdout.trim();
+    }
+    catch (error) {
+        // git notes show returns error if no note exists
+        if (error.message?.includes("no note found")) {
+            return "";
+        }
+        throw new Error(`Failed to retrieve note for commit ${commitHash}: ${error}`);
+    }
+}

package/dist/utils/gitNotes.test.d.ts

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

package/dist/utils/gitNotes.test.js

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { execSync } from "child_process";
+import { mkdirSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { attachTaskNote, getTaskNote, formatTaskNote } from "./gitNotes.js";
+describe("gitNotes", () => {
+    const testDir = join(process.cwd(), "test-git-repo");
+    let testCommitHash;
+    beforeEach(() => {
+        // Create a temporary git repository for testing
+        mkdirSync(testDir, { recursive: true });
+        process.chdir(testDir);
+        execSync("git init", { stdio: "pipe" });
+        execSync('git config user.email "test@example.com"', { stdio: "pipe" });
+        execSync('git config user.name "Test User"', { stdio: "pipe" });
+        // Create a test commit
+        writeFileSync(join(testDir, "test.txt"), "test content");
+        execSync("git add test.txt", { stdio: "pipe" });
+        execSync('git commit -m "test commit"', { stdio: "pipe" });
+        testCommitHash = execSync("git log -1 --format=%H", { encoding: "utf-8" }).trim();
+    });
+    afterEach(() => {
+        // Clean up
+        process.chdir(join(testDir, ".."));
+        rmSync(testDir, { recursive: true, force: true });
+    });
+    describe("formatTaskNote", () => {
+        it("should format a task note with all metadata", () => {
+            const note = formatTaskNote({
+                trackId: "track_123",
+                taskName: "Implement user authentication",
+                summary: "Added JWT-based auth",
+                filesChanged: ["src/auth.ts", "src/middleware/auth.ts"],
+                reason: "Required for secure user sessions"
+            });
+            expect(note).toContain("Track ID: track_123");
+            expect(note).toContain("Task: Implement user authentication");
+            expect(note).toContain("Summary: Added JWT-based auth");
+            expect(note).toContain("Files Changed:");
+            expect(note).toContain("- src/auth.ts");
+            expect(note).toContain("- src/middleware/auth.ts");
+            expect(note).toContain("Reason: Required for secure user sessions");
+        });
+        it("should handle empty files array", () => {
+            const note = formatTaskNote({
+                trackId: "track_123",
+                taskName: "Update docs",
+                summary: "Fixed typos",
+                filesChanged: [],
+                reason: "Documentation maintenance"
+            });
+            expect(note).toContain("Files Changed:");
+            expect(note).toContain("(none)");
+        });
+    });
+    describe("attachTaskNote", () => {
+        it("should attach a note to a commit", async () => {
+            const metadata = {
+                trackId: "track_123",
+                taskName: "Test task",
+                summary: "Test summary",
+                filesChanged: ["test.txt"],
+                reason: "Test reason"
+            };
+            await attachTaskNote(testCommitHash, metadata);
+            const note = await getTaskNote(testCommitHash);
+            expect(note).toContain("Track ID: track_123");
+            expect(note).toContain("Task: Test task");
+        });
+        it("should throw error for invalid commit hash", async () => {
+            const metadata = {
+                trackId: "track_123",
+                taskName: "Test task",
+                summary: "Test summary",
+                filesChanged: [],
+                reason: "Test reason"
+            };
+            await expect(attachTaskNote("invalid_hash", metadata)).rejects.toThrow();
+        });
+    });
+    describe("getTaskNote", () => {
+        it("should retrieve an attached note", async () => {
+            const metadata = {
+                trackId: "track_456",
+                taskName: "Another test",
+                summary: "Another summary",
+                filesChanged: ["file1.ts", "file2.ts"],
+                reason: "Testing retrieval"
+            };
+            await attachTaskNote(testCommitHash, metadata);
+            const note = await getTaskNote(testCommitHash);
+            expect(note).toContain("Track ID: track_456");
+            expect(note).toContain("Task: Another test");
+            expect(note).toContain("file1.ts");
+            expect(note).toContain("file2.ts");
+        });
+        it("should return empty string when no note exists", async () => {
+            const note = await getTaskNote(testCommitHash);
+            expect(note).toBe("");
+        });
+        it("should throw error for invalid commit hash", async () => {
+            await expect(getTaskNote("invalid_hash")).rejects.toThrow();
+        });
+    });
+});

package/dist/utils/ignoreMatcher.d.ts

@@ -0,0 +1,9 @@
+export interface IgnorePatterns {
+    gitignore: string[];
+    ignore: string[];
+    geminiignore: string[];
+}
+export declare const buildIgnoreMatcher: (_rootDir: string, patterns: IgnorePatterns) => {
+    ignores: (relativePath: string) => boolean;
+    shouldTraverse: (relativePath: string) => boolean;
+};

package/dist/utils/ignoreMatcher.js

@@ -0,0 +1,77 @@
+const safetyBlacklist = [".git", "node_modules", ".DS_Store"];
+const normalizePath = (relativePath) => relativePath.replace(/\\/g, "/").replace(/\/$/, "");
+const normalizePatterns = (rawPatterns) => rawPatterns
+    .map((pattern) => pattern.trim())
+    .filter((pattern) => pattern.length > 0 && !pattern.startsWith("#"));
+const matchesPattern = (normalizedPath, pattern) => {
+    if (pattern === "*")
+        return true;
+    if (pattern.startsWith("*.")) {
+        const ext = pattern.slice(1);
+        return normalizedPath.endsWith(ext);
+    }
+    if (pattern.includes("**")) {
+        let regexPattern = pattern;
+        if (pattern.startsWith("**/")) {
+            const remainder = pattern.slice(3);
+            regexPattern = `(^|.*/)${remainder.replace(/[.+?^${}()|[\]\\]/g, "\\$&")}`;
+        }
+        else if (pattern.endsWith("/**/*")) {
+            const prefix = pattern.slice(0, -5);
+            regexPattern = `${prefix.replace(/[.+?^${}()|[\]\\]/g, "\\$&")}/.*`;
+        }
+        else {
+            const segments = pattern.split("/");
+            const regexSegments = segments.map((segment, idx) => {
+                if (segment === "**") {
+                    if (idx === 0)
+                        return "(.*/)?";
+                    if (idx === segments.length - 1)
+                        return "(/.*)?";
+                    return "(/.*/|/)";
+                }
+                if (segment === "*")
+                    return "[^/]*";
+                return segment.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+            });
+            regexPattern = regexSegments.join("");
+        }
+        return new RegExp(`^${regexPattern}$`).test(normalizedPath);
+    }
+    if (normalizedPath === pattern)
+        return true;
+    return normalizedPath.startsWith(`${pattern}/`);
+};
+const hasAllowedDescendant = (normalizedPath, allowlist) => allowlist.some((allow) => allow === normalizedPath || allow.startsWith(`${normalizedPath}/`));
+export const buildIgnoreMatcher = (_rootDir, patterns) => {
+    const allPatterns = normalizePatterns([
+        ...patterns.gitignore,
+        ...patterns.ignore,
+        ...patterns.geminiignore,
+    ]);
+    const allowlist = allPatterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => {
+        return normalizePath(pattern.slice(1));
+    });
+    const ignores = allPatterns
+        .filter((pattern) => !pattern.startsWith("!"))
+        .map((pattern) => normalizePath(pattern));
+    const isIgnored = (relativePath) => {
+        const normalized = normalizePath(relativePath);
+        const parts = normalized.split("/").filter(Boolean);
+        if (parts.some((part) => safetyBlacklist.includes(part))) {
+            return !allowlist.some((allow) => matchesPattern(normalized, allow));
+        }
+        if (allowlist.some((allow) => matchesPattern(normalized, allow)))
+            return false;
+        return ignores.some((ignore) => matchesPattern(normalized, ignore));
+    };
+    const shouldTraverse = (relativePath) => {
+        if (relativePath === "." || relativePath === "")
+            return true;
+        const normalized = normalizePath(relativePath);
+        if (!isIgnored(normalized))
+            return true;
+        return hasAllowedDescendant(normalized, allowlist);
+    };
+    return { ignores: isIgnored, shouldTraverse };
+};

package/dist/utils/ignoreMatcher.test.d.ts

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