opencode-orchestrator-plugin 1.0.0-beta.8 → 1.0.0-beta.9

package/dist/index.js

@@ -5,6 +5,8 @@ import NewTrackPromptJson from "./prompts/orchestrator/newTrack.json" with { typ
 import RevertPromptJson from "./prompts/orchestrator/revert.json" with { type: "json" };
 import SetupPromptJson from "./prompts/orchestrator/setup.json" with { type: "json" };
 import StatusPromptJson from "./prompts/orchestrator/status.json" with { type: "json" };
+import { detectOrchestratorConfig } from "./utils/configDetection.js";
+import { buildIgnoreMatcher } from "./utils/ignoreMatcher.js";
 const asPrompt = (prompt) => (typeof prompt === "string" ? prompt : "");
 const asDescription = (description) => typeof description === "string" ? description : undefined;
 export const MyPlugin = async ({ directory, }) => {
@@ -19,41 +21,15 @@ export const MyPlugin = async ({ directory, }) => {
             .map((line) => line.trim())
             .filter((line) => line.length > 0 && !line.startsWith("#"));
     };
-    const buildIgnoreMatcher = (rootDir) => {
+    const getFileTreeSummary = (rootDir, maxEntries = 200, maxChars = 4000) => {
         const ignoreFile = path.join(rootDir, ".ignore");
         const geminiIgnoreFile = path.join(rootDir, ".geminiignore");
         const gitIgnoreFile = path.join(rootDir, ".gitignore");
-        const gitIgnorePatterns = readIgnoreFile(gitIgnoreFile);
-        const ignoreOverrides = readIgnoreFile(ignoreFile)
-            .filter((pattern) => pattern.startsWith("!"))
-            .map((pattern) => pattern.slice(1));
-        const geminiIgnorePatterns = readIgnoreFile(geminiIgnoreFile);
-        const ignored = new Set();
-        for (const pattern of gitIgnorePatterns.concat(geminiIgnorePatterns)) {
-            if (!pattern.startsWith("#") && !pattern.startsWith("!")) {
-                ignored.add(pattern.replace(/\/$/, ""));
-            }
-        }
-        const allowed = new Set(ignoreOverrides.map((pattern) => pattern.replace(/\/$/, "")));
-        const isIgnored = (relativePath) => {
-            const normalized = relativePath.replace(/\\/g, "/");
-            if (allowed.size > 0) {
-                for (const allow of allowed) {
-                    if (normalized === allow || normalized.startsWith(`${allow}/`))
-                        return false;
-                }
-            }
-            for (const ignorePattern of ignored) {
-                if (normalized === ignorePattern || normalized.startsWith(`${ignorePattern}/`)) {
-                    return true;
-                }
-            }
-            return false;
-        };
-        return { ignores: isIgnored };
-    };
-    const getFileTreeSummary = (rootDir, maxEntries = 200, maxChars = 4000) => {
-        const ig = buildIgnoreMatcher(rootDir);
+        const ig = buildIgnoreMatcher(rootDir, {
+            gitignore: readIgnoreFile(gitIgnoreFile),
+            ignore: readIgnoreFile(ignoreFile),
+            geminiignore: readIgnoreFile(geminiIgnoreFile),
+        });
         const directories = new Set();
         const queue = [rootDir];
         while (queue.length > 0) {
@@ -64,13 +40,17 @@ export const MyPlugin = async ({ directory, }) => {
             for (const entry of entries) {
                 const entryPath = path.join(current, entry.name);
                 const relativePath = path.relative(rootDir, entryPath) || ".";
-                if (ig.ignores(relativePath)) {
-                    continue;
-                }
                 if (entry.isDirectory()) {
-                    directories.add(path.relative(rootDir, entryPath) || ".");
+                    const normalizedDir = relativePath === "." ? "" : relativePath;
+                    if (!ig.shouldTraverse(normalizedDir)) {
+                        continue;
+                    }
+                    directories.add(relativePath || ".");
                     queue.push(entryPath);
                 }
+                else if (ig.ignores(relativePath)) {
+                    continue;
+                }
             }
         }
         const sorted = Array.from(directories).sort();
@@ -98,15 +78,18 @@ export const MyPlugin = async ({ directory, }) => {
         return fs.existsSync(setupStatePath);
     };
     const setupOccurred = isOrchestratorSetup();
+    const configDetection = detectOrchestratorConfig();
     return {
         config: async (_config) => {
             _config.command = {
                 ..._config.command,
                 "orchestrator:implement": {
+                    agent: "orchestrator",
                     template: asPrompt(ImplementPromptJson.prompt) + `
             Environment Details: 
               - Directory: ${directory}
               - Orchestrator Setup: ${setupOccurred}
+              - Synergy Active (OMO): ${configDetection.synergyActive}
               - Current Orchestrator Files (Location: ${directory}/orchestrator)
                   File Tree:
                     ${fileHeirarchy}
@@ -114,33 +97,39 @@ export const MyPlugin = async ({ directory, }) => {
                     description: asDescription(ImplementPromptJson.description),
                 },
                 "orchestrator:newTrack": {
+                    agent: "orchestrator",
                     template: asPrompt(NewTrackPromptJson.prompt),
                     description: asDescription(NewTrackPromptJson.description),
                 },
                 "orchestrator:revert": {
+                    agent: "orchestrator",
                     template: asPrompt(RevertPromptJson.prompt),
                     description: asDescription(RevertPromptJson.description),
                 },
                 "orchestrator:setup": {
+                    agent: "orchestrator",
                     template: asPrompt(SetupPromptJson.prompt) + `
             Environment Details: 
               - Directory: ${directory}
               - Orchestrator Setup: ${setupOccurred}
+              - Synergy Active (OMO): ${configDetection.synergyActive}
               - Current Orchestrator Files (with tracks) (${directory}/orchestrator)
                 File Tree:
                   ${fileHeirarchy}
-
+ 
               **CRITICAL ENVIRONTMENTAL OVERRIDE:**: You are running inside OpenCode. Use ./config/opencode/node_modules/opencode-orchestrator-plugin for setup operations and respect .ignore (allowlist), .geminiignore, and .gitignore patterns when excluding files.
           `,
                     description: asDescription(SetupPromptJson.description),
                 },
                 "orchestrator:status": {
+                    agent: "orchestrator",
                     template: asPrompt(StatusPromptJson.prompt) + `
-
+ 
           
           ***Current Environment Details***: 
             - Current Working Directory: ${directory}
             - Orchestrator Setup Process Completed: ${setupOccurred}
+            - Synergy Active (OMO): ${configDetection.synergyActive}
             - Current Orchestrator Files (with tracks) (${directory}/orchestrator)
                 File Tree:
                   ${fileHeirarchy}

package/dist/prompts/agent/orchestrator.md

@@ -27,7 +27,13 @@ Your mission is to ensure that software development follows a rigorous, context-
 - **Model Selection**: You prefer "flash" models for efficiency and speed during planning and tool orchestration.
 - **Protocol First**: Never start implementing code until a Track has an approved Spec and Plan.
 - **Collaboration**: You work alongside the user. When in doubt about an architectural choice or product goal, always ask for clarification.
-- **Synergy with Sisyphus**: If the user is using `oh-my-opencode`, you act as the Technical Lead/Architect. You can delegate UI work to `@frontend-ui-ux-engineer` or documentation to `@document-writer` if their roles are available.
+- **Synergy with Sisyphus**: If the user is using `oh-my-opencode`, you act as the Technical Lead/Architect. You can delegate tasks to specialized agents using the `orchestrator_delegate` tool:
+    - `@frontend-ui-ux-engineer`: For UI/UX implementation and frontend components.
+    - `@document-writer`: For documentation, READMEs, and technical guides.
+    - `@sisyphus`: For general implementation, coordination, and bug fixing.
+    - `@oracle`: For architectural decisions, deep code analysis, and expert reviews.
+    - `@librarian`: For external library research, documentation retrieval, and finding usage examples.
+    - `@explore`: For codebase search, understanding unfamiliar code, and finding logic.
 
 ## Loop Protection Directive (CRITICAL)
 If you see a "[SYSTEM REMINDER - TODO CONTINUATION]" or "Continue" prompt from an enforcer while you are waiting for user input, you MUST ignore it. Respond with: "I am currently in an interactive Orchestrator phase. Awaiting user response."

package/dist/utils/configDetection.d.ts

@@ -0,0 +1,6 @@
+export interface ConfigDetectionResult {
+    hasOrchestratorInOpenCode: boolean;
+    hasOrchestratorInOMO: boolean;
+    synergyActive: boolean;
+}
+export declare function detectOrchestratorConfig(): ConfigDetectionResult;

package/dist/utils/configDetection.js

@@ -0,0 +1,35 @@
+import { join } from "path";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+export function detectOrchestratorConfig() {
+    const opencodeConfigDir = join(homedir(), ".config", "opencode");
+    const opencodeJsonPath = join(opencodeConfigDir, "opencode.json");
+    const omoJsonPath = join(opencodeConfigDir, "oh-my-opencode.json");
+    let hasOrchestratorInOpenCode = false;
+    let hasOrchestratorInOMO = false;
+    if (existsSync(opencodeJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(opencodeJsonPath, "utf-8"));
+            if (config.agent && config.agent.orchestrator) {
+                hasOrchestratorInOpenCode = true;
+            }
+        }
+        catch (e) {
+        }
+    }
+    if (existsSync(omoJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(omoJsonPath, "utf-8"));
+            if (config.agents && config.agents.orchestrator) {
+                hasOrchestratorInOMO = true;
+            }
+        }
+        catch (e) {
+        }
+    }
+    return {
+        hasOrchestratorInOpenCode,
+        hasOrchestratorInOMO,
+        synergyActive: hasOrchestratorInOMO,
+    };
+}

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

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

package/dist/utils/configDetection.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { existsSync, readFileSync } from "fs";
+import { detectOrchestratorConfig } from "./configDetection.js";
+vi.mock("fs", () => ({
+    existsSync: vi.fn(),
+    readFileSync: vi.fn(),
+}));
+vi.mock("os", () => ({
+    homedir: vi.fn(() => "/home/user"),
+}));
+describe("configDetection", () => {
+    const opencodeJsonPath = "/home/user/.config/opencode/opencode.json";
+    const omoJsonPath = "/home/user/.config/opencode/oh-my-opencode.json";
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should detect orchestrator in opencode.json", () => {
+        vi.mocked(existsSync).mockImplementation((path) => path === opencodeJsonPath);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === opencodeJsonPath) {
+                return JSON.stringify({ agent: { orchestrator: {} } });
+            }
+            return "";
+        });
+        const result = detectOrchestratorConfig();
+        expect(result.hasOrchestratorInOpenCode).toBe(true);
+        expect(result.hasOrchestratorInOMO).toBe(false);
+        expect(result.synergyActive).toBe(false);
+    });
+    it("should detect orchestrator in oh-my-opencode.json and activate synergy", () => {
+        vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === omoJsonPath) {
+                return JSON.stringify({ agents: { orchestrator: {} } });
+            }
+            return "";
+        });
+        const result = detectOrchestratorConfig();
+        expect(result.hasOrchestratorInOpenCode).toBe(false);
+        expect(result.hasOrchestratorInOMO).toBe(true);
+        expect(result.synergyActive).toBe(true);
+    });
+    it("should handle both configs present", () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === opencodeJsonPath) {
+                return JSON.stringify({ agent: { orchestrator: {} } });
+            }
+            if (path === omoJsonPath) {
+                return JSON.stringify({ agents: { orchestrator: {} } });
+            }
+            return "";
+        });
+        const result = detectOrchestratorConfig();
+        expect(result.hasOrchestratorInOpenCode).toBe(true);
+        expect(result.hasOrchestratorInOMO).toBe(true);
+        expect(result.synergyActive).toBe(true);
+    });
+    it("should handle missing configs", () => {
+        vi.mocked(existsSync).mockReturnValue(false);
+        const result = detectOrchestratorConfig();
+        expect(result.hasOrchestratorInOpenCode).toBe(false);
+        expect(result.hasOrchestratorInOMO).toBe(false);
+        expect(result.synergyActive).toBe(false);
+    });
+    it("should handle malformed JSON", () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        vi.mocked(readFileSync).mockReturnValue("invalid json");
+        const result = detectOrchestratorConfig();
+        expect(result.hasOrchestratorInOpenCode).toBe(false);
+        expect(result.hasOrchestratorInOMO).toBe(false);
+        expect(result.synergyActive).toBe(false);
+    });
+});

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 {};

package/dist/utils/ignoreMatcher.test.js

@@ -0,0 +1,126 @@
+import { describe, it, expect } from "vitest";
+import { buildIgnoreMatcher } from "./ignoreMatcher.js";
+describe("ignoreMatcher", () => {
+    it("should always ignore .git directory", () => {
+        const matcher = buildIgnoreMatcher("/root", { gitignore: [], ignore: [], geminiignore: [] });
+        expect(matcher.ignores(".git")).toBe(true);
+        expect(matcher.ignores(".git/config")).toBe(true);
+        expect(matcher.ignores("src/.git")).toBe(true);
+    });
+    it("should always ignore node_modules directory", () => {
+        const matcher = buildIgnoreMatcher("/root", { gitignore: [], ignore: [], geminiignore: [] });
+        expect(matcher.ignores("node_modules")).toBe(true);
+        expect(matcher.ignores("node_modules/package/index.js")).toBe(true);
+        expect(matcher.ignores("src/node_modules")).toBe(true);
+    });
+    it("should always ignore .DS_Store", () => {
+        const matcher = buildIgnoreMatcher("/root", { gitignore: [], ignore: [], geminiignore: [] });
+        expect(matcher.ignores(".DS_Store")).toBe(true);
+        expect(matcher.ignores("src/.DS_Store")).toBe(true);
+    });
+    it("should ignore patterns from gitignore", () => {
+        const matcher = buildIgnoreMatcher("/root", {
+            gitignore: ["dist", "*.log"],
+            ignore: [],
+            geminiignore: []
+        });
+        expect(matcher.ignores("dist")).toBe(true);
+        expect(matcher.ignores("dist/index.js")).toBe(true);
+        expect(matcher.ignores("error.log")).toBe(true);
+        expect(matcher.ignores("src/app.ts")).toBe(false);
+    });
+    it("should support negation patterns with !", () => {
+        const matcher = buildIgnoreMatcher("/root", {
+            gitignore: ["orchestrator/"],
+            ignore: ["!orchestrator/tracks/"],
+            geminiignore: []
+        });
+        // orchestrator/ is ignored by gitignore
+        expect(matcher.ignores("orchestrator")).toBe(true);
+        expect(matcher.ignores("orchestrator/guidelines.md")).toBe(true);
+        // But orchestrator/tracks/ is allowed by negation in .ignore
+        expect(matcher.ignores("orchestrator/tracks")).toBe(false);
+        expect(matcher.ignores("orchestrator/tracks/plan.md")).toBe(false);
+    });
+    it("should allow traversal when a descendant is allowlisted", () => {
+        const matcher = buildIgnoreMatcher("/root", {
+            gitignore: ["orchestrator/"],
+            ignore: ["!orchestrator/tracks/"],
+            geminiignore: []
+        });
+        expect(matcher.shouldTraverse("orchestrator")).toBe(true);
+        expect(matcher.shouldTraverse("orchestrator/tracks")).toBe(true);
+        expect(matcher.shouldTraverse("orchestrator/docs")).toBe(false);
+    });
+    it("should handle directory-specific patterns", () => {
+        const matcher = buildIgnoreMatcher("/root", {
+            gitignore: ["logs/"],
+            ignore: [],
+            geminiignore: []
+        });
+        expect(matcher.ignores("logs")).toBe(true);
+        expect(matcher.ignores("logs/test.log")).toBe(true);
+        expect(matcher.ignores("catalogs/item.txt")).toBe(false);
+    });
+    it("should prioritize negation over ignore", () => {
+        const matcher = buildIgnoreMatcher("/root", {
+            gitignore: ["*"],
+            ignore: ["!src/"],
+            geminiignore: []
+        });
+        expect(matcher.ignores("README.md")).toBe(true);
+        expect(matcher.ignores("src")).toBe(false);
+        expect(matcher.ignores("src/index.ts")).toBe(false);
+    });
+    it("should handle comments and empty lines in ignore files", () => {
+        const matcher = buildIgnoreMatcher("/root", {
+            gitignore: ["# This is a comment", "", "  ", "dist"],
+            ignore: [],
+            geminiignore: []
+        });
+        expect(matcher.ignores("dist")).toBe(true);
+        expect(matcher.ignores("src")).toBe(false);
+    });
+    it("should support **/ prefix for any depth matching", () => {
+        const matcher = buildIgnoreMatcher("/root", {
+            gitignore: ["**/temp"],
+            ignore: [],
+            geminiignore: []
+        });
+        expect(matcher.ignores("temp")).toBe(true);
+        expect(matcher.ignores("src/temp")).toBe(true);
+        expect(matcher.ignores("src/nested/temp")).toBe(true);
+        expect(matcher.ignores("src/temporary")).toBe(false);
+    });
+    it("should support **/* suffix for recursive file matching", () => {
+        const matcher = buildIgnoreMatcher("/root", {
+            gitignore: ["logs/**/*"],
+            ignore: [],
+            geminiignore: []
+        });
+        expect(matcher.ignores("logs/error.log")).toBe(true);
+        expect(matcher.ignores("logs/nested/debug.log")).toBe(true);
+        expect(matcher.ignores("logs")).toBe(false);
+        expect(matcher.ignores("other/error.log")).toBe(false);
+    });
+    it("should support middle ** for any depth matching", () => {
+        const matcher = buildIgnoreMatcher("/root", {
+            gitignore: ["src/**/test"],
+            ignore: [],
+            geminiignore: []
+        });
+        expect(matcher.ignores("src/test")).toBe(true);
+        expect(matcher.ignores("src/nested/test")).toBe(true);
+        expect(matcher.ignores("src/very/deeply/nested/test")).toBe(true);
+        expect(matcher.ignores("other/test")).toBe(false);
+    });
+    it("should differentiate trailing slash for directories only", () => {
+        const matcher = buildIgnoreMatcher("/root", {
+            gitignore: ["build/"],
+            ignore: [],
+            geminiignore: []
+        });
+        expect(matcher.ignores("build")).toBe(true);
+        expect(matcher.ignores("build/output.js")).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-orchestrator-plugin",
-  "version": "1.0.0-beta.8",
+  "version": "1.0.0-beta.9",
   "description": "Orchestrator plugin for OpenCode",
   "type": "module",
   "repository": {