cortex-agents 2.3.1 → 3.4.0

package/dist/tools/cortex.js

@@ -151,13 +151,13 @@ Plans: ${planCount}`;
 /**
  * cortex_configure — Write per-project model configuration to ./opencode.json.
  *
- * Accepts a primary model (for build/plan/debug) and a subagent model
- * (for fullstack/testing/security/devops). Merges into any existing
+ * Accepts a primary model (for implement/architect/fix/audit) and a subagent model
+ * (for crosslayer/qa/guard/ship). Merges into any existing
  * opencode.json at the project root, preserving other settings.
  */
 export const configure = tool({
     description: "Save per-project model configuration to ./opencode.json. " +
-        "Sets the model for primary agents (build, plan, debug) and subagents (fullstack, testing, security, devops). " +
+        "Sets the model for primary agents (implement, architect, fix, audit) and subagents (crosslayer, qa, guard, ship). " +
         "Available models — Premium: " +
         MODEL_REGISTRY.filter((m) => m.tier === "premium")
             .map((m) => `${m.name} (${m.id})`)
@@ -174,10 +174,10 @@ export const configure = tool({
     args: {
         primaryModel: z
             .string()
-            .describe("Model ID for primary agents (build, plan, debug). Format: provider/model-name"),
+            .describe("Model ID for primary agents (implement, architect, fix, audit). Format: provider/model-name"),
         subagentModel: z
             .string()
-            .describe("Model ID for subagents (fullstack, testing, security, devops). Format: provider/model-name"),
+            .describe("Model ID for subagents (crosslayer, qa, guard, ship). Format: provider/model-name"),
     },
     async execute(args, context) {
         const configPath = path.join(context.worktree, "opencode.json");
@@ -246,10 +246,10 @@ export const configure = tool({
         return `✓ Model configuration saved to:
   ${savedTo}
 
-Primary agents (build, plan, debug):
+Primary agents (implement, architect, fix, audit):
   → ${primaryDisplay} (${args.primaryModel})
 
-Subagents (fullstack, testing, security, devops):
+Subagents (crosslayer, qa, guard, ship):
   → ${subagentDisplay} (${args.subagentModel})
 
 Restart OpenCode to apply changes.`;

package/dist/tools/environment.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Environment Detection Tool
+ *
+ * Provides agents with information about the current development environment
+ * (IDE, terminal, editor) to offer contextually appropriate worktree launch options.
+ *
+ * Uses two detection systems:
+ *   - IDE detection (ide.ts) — for "Open in IDE" options
+ *   - Terminal detection (terminal.ts) — for "Open in terminal tab" options
+ *
+ * The terminal detection uses a multi-strategy chain:
+ *   1. Environment variables (fast, synchronous)
+ *   2. Process-tree walk (finds terminal in parent processes)
+ *   3. Frontmost app detection (macOS only)
+ *   4. User preference (.cortex/config.json)
+ */
+export declare const detectEnvironment: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Quick environment check tool for agents.
+ * Returns a simplified response for quick decision-making.
+ */
+export declare const getEnvironmentInfo: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+//# sourceMappingURL=environment.d.ts.map

package/dist/tools/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/tools/environment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAMH,eAAO,MAAM,iBAAiB;;;;CAgD5B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;CA4B7B,CAAC"}

package/dist/tools/environment.js

@@ -0,0 +1,93 @@
+/**
+ * Environment Detection Tool
+ *
+ * Provides agents with information about the current development environment
+ * (IDE, terminal, editor) to offer contextually appropriate worktree launch options.
+ *
+ * Uses two detection systems:
+ *   - IDE detection (ide.ts) — for "Open in IDE" options
+ *   - Terminal detection (terminal.ts) — for "Open in terminal tab" options
+ *
+ * The terminal detection uses a multi-strategy chain:
+ *   1. Environment variables (fast, synchronous)
+ *   2. Process-tree walk (finds terminal in parent processes)
+ *   3. Frontmost app detection (macOS only)
+ *   4. User preference (.cortex/config.json)
+ */
+import { tool } from "@opencode-ai/plugin";
+import { detectIDEWithCLICheck, formatEnvironmentReport, generateEnvironmentRecommendations } from "../utils/ide.js";
+import { detectDriver, detectTerminalDriver } from "../utils/terminal.js";
+export const detectEnvironment = tool({
+    description: "Detect the current development environment (IDE, terminal, editor) " +
+        "to offer contextually appropriate worktree launch options. " +
+        "Returns environment info and recommended launch options.",
+    args: {},
+    async execute(args, context) {
+        // Use async detection that verifies CLI availability in PATH
+        const ide = await detectIDEWithCLICheck();
+        const ideDriver = detectDriver();
+        // Multi-strategy terminal detection (the one used for "Open in terminal tab")
+        const terminalDetection = await detectTerminalDriver(context.worktree);
+        // Format the report (now includes CLI availability status)
+        const report = formatEnvironmentReport(ide, terminalDetection.driver.name);
+        // Add CLI status section
+        const additionalInfo = [];
+        additionalInfo.push(``, `### CLI Status`, ``);
+        additionalInfo.push(`- IDE: ${ide.name}`);
+        additionalInfo.push(`- IDE Driver: ${ideDriver.name}`);
+        additionalInfo.push(`- Terminal Emulator: **${terminalDetection.driver.name}**`);
+        additionalInfo.push(`- Platform: ${process.platform}`);
+        if (ide.cliBinary) {
+            if (ide.cliAvailable) {
+                additionalInfo.push(`- CLI: \`${ide.cliBinary}\` available in PATH`);
+            }
+            else {
+                additionalInfo.push(`- CLI: \`${ide.cliBinary}\` **NOT found** in PATH`);
+                if (ide.cliInstallHint) {
+                    additionalInfo.push(`- Fix: ${ide.cliInstallHint}`);
+                }
+            }
+        }
+        // Terminal detection details
+        additionalInfo.push(``, `### Terminal Detection`, ``);
+        additionalInfo.push(`- Strategy: **${terminalDetection.strategy}**`);
+        if (terminalDetection.detail) {
+            additionalInfo.push(`- Detail: ${terminalDetection.detail}`);
+        }
+        additionalInfo.push(`- Driver: ${terminalDetection.driver.name}`);
+        additionalInfo.push(``);
+        additionalInfo.push(`When "Open in terminal tab" is selected, a new tab will open in **${terminalDetection.driver.name}**.`);
+        return report + additionalInfo.join("\n");
+    },
+});
+/**
+ * Quick environment check tool for agents.
+ * Returns a simplified response for quick decision-making.
+ */
+export const getEnvironmentInfo = tool({
+    description: "Get quick environment info for deciding worktree launch options. " +
+        "Returns IDE type, terminal name, and whether to offer IDE-specific options.",
+    args: {},
+    async execute(args, context) {
+        const ide = await detectIDEWithCLICheck();
+        const terminalDetection = await detectTerminalDriver(context.worktree);
+        return JSON.stringify({
+            ide: {
+                type: ide.type,
+                name: ide.name,
+                hasIntegratedTerminal: ide.hasIntegratedTerminal,
+                canOpenInWindow: ide.canOpenInWindow,
+                cliAvailable: ide.cliAvailable,
+                cliBinary: ide.cliBinary,
+                cliInstallHint: ide.cliInstallHint,
+            },
+            terminal: {
+                name: terminalDetection.driver.name,
+                detectionStrategy: terminalDetection.strategy,
+                detectionDetail: terminalDetection.detail,
+            },
+            platform: process.platform,
+            recommendations: generateEnvironmentRecommendations(ide),
+        }, null, 2);
+    },
+});

package/dist/tools/github.d.ts

@@ -0,0 +1,42 @@
+export declare const status: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const issues: {
+    description: string;
+    args: {
+        state: import("zod").ZodOptional<import("zod").ZodEnum<{
+            closed: "closed";
+            open: "open";
+            all: "all";
+        }>>;
+        labels: import("zod").ZodOptional<import("zod").ZodString>;
+        milestone: import("zod").ZodOptional<import("zod").ZodString>;
+        assignee: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        detailed: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        state?: "closed" | "open" | "all" | undefined;
+        labels?: string | undefined;
+        milestone?: string | undefined;
+        assignee?: string | undefined;
+        limit?: number | undefined;
+        detailed?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const projects: {
+    description: string;
+    args: {
+        projectNumber: import("zod").ZodOptional<import("zod").ZodNumber>;
+        status: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        projectNumber?: number | undefined;
+        status?: string | undefined;
+        limit?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+//# sourceMappingURL=github.d.ts.map

package/dist/tools/github.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../../src/tools/github.ts"],"names":[],"mappings":"AAwCA,eAAO,MAAM,MAAM;;;;CAgDjB,CAAC;AAIH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;CAsEjB,CAAC;AAIH,eAAO,MAAM,QAAQ;;;;;;;;;;;;CA0EnB,CAAC"}

package/dist/tools/github.js

@@ -0,0 +1,200 @@
+import { tool } from "@opencode-ai/plugin";
+import { checkGhAvailability, fetchIssues, fetchProjects, fetchProjectItems, formatIssueList, formatIssueForPlan, formatProjectItemList, } from "../utils/github.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Validate GitHub CLI availability and return status.
+ * Returns a formatted error string if not available, or the status object.
+ */
+async function requireGh(cwd) {
+    const status = await checkGhAvailability(cwd);
+    if (!status.installed) {
+        return {
+            ok: false,
+            error: "✗ GitHub CLI (gh) is not installed.\n\nInstall it from https://cli.github.com/ and run `gh auth login`.",
+        };
+    }
+    if (!status.authenticated) {
+        return {
+            ok: false,
+            error: "✗ GitHub CLI is not authenticated.\n\nRun `gh auth login` to authenticate.",
+        };
+    }
+    return { ok: true, status };
+}
+// ─── Tool: github_status ─────────────────────────────────────────────────────
+export const status = tool({
+    description: "Check GitHub CLI availability, authentication, and detect GitHub Projects for the current repository. " +
+        "Use this first to verify the repo is connected before listing issues or projects.",
+    args: {},
+    async execute(_args, context) {
+        const status = await checkGhAvailability(context.worktree);
+        const lines = [];
+        // Installation
+        lines.push(status.installed ? "✓ GitHub CLI installed" : "✗ GitHub CLI not installed");
+        if (!status.installed) {
+            lines.push("  Install from https://cli.github.com/");
+            return lines.join("\n");
+        }
+        // Authentication
+        lines.push(status.authenticated ? "✓ Authenticated" : "✗ Not authenticated");
+        if (!status.authenticated) {
+            lines.push("  Run: gh auth login");
+            return lines.join("\n");
+        }
+        // Remote
+        if (status.hasRemote && status.repoOwner && status.repoName) {
+            lines.push(`✓ Repository: ${status.repoOwner}/${status.repoName}`);
+            // Fetch projects
+            const projects = await fetchProjects(context.worktree, status.repoOwner);
+            status.projects = projects;
+            if (projects.length > 0) {
+                lines.push("");
+                lines.push(`GitHub Projects (${projects.length}):`);
+                for (const p of projects) {
+                    lines.push(`  #${p.number}: ${p.title}`);
+                }
+            }
+            else {
+                lines.push("  No GitHub Projects found for this repository owner.");
+            }
+        }
+        else {
+            lines.push("✗ No GitHub remote (origin) configured");
+            lines.push("  Add one with: git remote add origin <url>");
+        }
+        return lines.join("\n");
+    },
+});
+// ─── Tool: github_issues ─────────────────────────────────────────────────────
+export const issues = tool({
+    description: "List GitHub issues for the current repository, filterable by state, labels, milestone, and assignee. " +
+        "Returns a formatted list suitable for selecting issues to plan. " +
+        "Set `detailed` to true to get full issue descriptions for plan seeding.",
+    args: {
+        state: tool.schema
+            .enum(["open", "closed", "all"])
+            .optional()
+            .describe("Filter by issue state (default: open)"),
+        labels: tool.schema
+            .string()
+            .optional()
+            .describe("Filter by labels (comma-separated, e.g., 'bug,priority:high')"),
+        milestone: tool.schema
+            .string()
+            .optional()
+            .describe("Filter by milestone name"),
+        assignee: tool.schema
+            .string()
+            .optional()
+            .describe("Filter by assignee username"),
+        limit: tool.schema
+            .number()
+            .optional()
+            .describe("Maximum number of issues to return (default: 20, max: 100)"),
+        detailed: tool.schema
+            .boolean()
+            .optional()
+            .describe("If true, return full issue details formatted for plan seeding (default: false)"),
+    },
+    async execute(args, context) {
+        const check = await requireGh(context.worktree);
+        if (!check.ok)
+            return check.error;
+        const limit = Math.min(Math.max(args.limit ?? 20, 1), 100);
+        try {
+            const issueList = await fetchIssues(context.worktree, {
+                state: args.state ?? "open",
+                labels: args.labels,
+                milestone: args.milestone,
+                assignee: args.assignee,
+                limit,
+            });
+            if (issueList.length === 0) {
+                const filters = [];
+                if (args.state)
+                    filters.push(`state: ${args.state}`);
+                if (args.labels)
+                    filters.push(`labels: ${args.labels}`);
+                if (args.milestone)
+                    filters.push(`milestone: ${args.milestone}`);
+                if (args.assignee)
+                    filters.push(`assignee: ${args.assignee}`);
+                const filterStr = filters.length > 0 ? ` (filters: ${filters.join(", ")})` : "";
+                return `No issues found${filterStr}.`;
+            }
+            const header = `Found ${issueList.length} issue(s):\n\n`;
+            if (args.detailed) {
+                // Full detail mode for plan seeding
+                const formatted = issueList.map((issue) => formatIssueForPlan(issue)).join("\n\n---\n\n");
+                return header + formatted;
+            }
+            // Compact list mode for selection
+            return header + formatIssueList(issueList);
+        }
+        catch (error) {
+            return `✗ Error fetching issues: ${error.message || error}`;
+        }
+    },
+});
+// ─── Tool: github_projects ───────────────────────────────────────────────────
+export const projects = tool({
+    description: "List GitHub Project boards and their work items for the current repository. " +
+        "Without a projectNumber, lists all projects. " +
+        "With a projectNumber, lists items from that specific project board.",
+    args: {
+        projectNumber: tool.schema
+            .number()
+            .optional()
+            .describe("Specific project number to list items from (omit to list all projects)"),
+        status: tool.schema
+            .string()
+            .optional()
+            .describe("Filter project items by status column (e.g., 'Todo', 'In Progress')"),
+        limit: tool.schema
+            .number()
+            .optional()
+            .describe("Maximum number of items to return (default: 30)"),
+    },
+    async execute(args, context) {
+        const check = await requireGh(context.worktree);
+        if (!check.ok)
+            return check.error;
+        const { status: ghStatus } = check;
+        if (!ghStatus.hasRemote || !ghStatus.repoOwner) {
+            return "✗ No GitHub remote (origin) configured. Cannot fetch projects.";
+        }
+        const owner = ghStatus.repoOwner;
+        try {
+            // If no project number specified, list all projects
+            if (args.projectNumber === undefined) {
+                const projectList = await fetchProjects(context.worktree, owner);
+                if (projectList.length === 0) {
+                    return `No GitHub Projects found for ${owner}.`;
+                }
+                const lines = [`GitHub Projects for ${owner} (${projectList.length}):\n`];
+                for (const p of projectList) {
+                    lines.push(`  #${p.number}: ${p.title}`);
+                }
+                lines.push("");
+                lines.push("Use github_projects with a projectNumber to list items from a specific project.");
+                return lines.join("\n");
+            }
+            // Fetch items from a specific project (cap limit for safety)
+            const limit = Math.min(Math.max(args.limit ?? 30, 1), 100);
+            const items = await fetchProjectItems(context.worktree, owner, args.projectNumber, {
+                status: args.status,
+                limit,
+            });
+            if (items.length === 0) {
+                const statusFilter = args.status ? ` with status "${args.status}"` : "";
+                return `No items found in project #${args.projectNumber}${statusFilter}.`;
+            }
+            const statusFilter = args.status ? ` (status: ${args.status})` : "";
+            const header = `Project #${args.projectNumber} — ${items.length} item(s)${statusFilter}:\n\n`;
+            return header + formatProjectItemList(items);
+        }
+        catch (error) {
+            return `✗ Error fetching projects: ${error.message || error}`;
+        }
+    },
+});

package/dist/tools/repl.d.ts

@@ -0,0 +1,50 @@
+/**
+ * REPL Loop Tools
+ *
+ * Four tools for the implement agent's iterative task-by-task development loop:
+ *   - repl_init    — Initialize a loop from a plan
+ *   - repl_status  — Get current progress and next task
+ *   - repl_report  — Report task outcome (pass/fail/skip)
+ *   - repl_summary — Generate markdown summary for PR body
+ */
+export declare const init: {
+    description: string;
+    args: {
+        planFilename: import("zod").ZodString;
+        buildCommand: import("zod").ZodOptional<import("zod").ZodString>;
+        testCommand: import("zod").ZodOptional<import("zod").ZodString>;
+        maxRetries: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        planFilename: string;
+        buildCommand?: string | undefined;
+        testCommand?: string | undefined;
+        maxRetries?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const status: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const report: {
+    description: string;
+    args: {
+        result: import("zod").ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            skip: "skip";
+        }>;
+        detail: import("zod").ZodString;
+    };
+    execute(args: {
+        result: "pass" | "fail" | "skip";
+        detail: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const summary: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+//# sourceMappingURL=repl.d.ts.map

package/dist/tools/repl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repl.d.ts","sourceRoot":"","sources":["../../src/tools/repl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAwBH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;CAqGf,CAAC;AAIH,eAAO,MAAM,MAAM;;;;CAyBjB,CAAC;AAIH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;CAwCjB,CAAC;AA8EH,eAAO,MAAM,OAAO;;;;CAclB,CAAC"}