cortex-agents 1.0.0

package/dist/tools/session.js

@@ -0,0 +1,175 @@
+import { tool } from "@opencode-ai/plugin";
+import * as fs from "fs";
+import * as path from "path";
+const CORTEX_DIR = ".cortex";
+const SESSIONS_DIR = "sessions";
+function getDatePrefix() {
+    const now = new Date();
+    return now.toISOString().split("T")[0]; // YYYY-MM-DD
+}
+function ensureSessionsDir(worktree) {
+    const cortexPath = path.join(worktree, CORTEX_DIR);
+    const sessionsPath = path.join(cortexPath, SESSIONS_DIR);
+    if (!fs.existsSync(sessionsPath)) {
+        fs.mkdirSync(sessionsPath, { recursive: true });
+    }
+    return sessionsPath;
+}
+function generateSessionId() {
+    return Math.random().toString(36).substring(2, 10);
+}
+export const save = tool({
+    description: "Save a session summary with key decisions to .cortex/sessions/",
+    args: {
+        summary: tool.schema
+            .string()
+            .describe("Brief summary of what was accomplished in this session"),
+        decisions: tool.schema
+            .array(tool.schema.string())
+            .describe("List of key decisions made during the session"),
+        filesChanged: tool.schema
+            .array(tool.schema.string())
+            .optional()
+            .describe("Optional list of files that were modified"),
+        relatedPlan: tool.schema
+            .string()
+            .optional()
+            .describe("Optional filename of related plan"),
+        branch: tool.schema
+            .string()
+            .optional()
+            .describe("Git branch this work was done on"),
+    },
+    async execute(args, context) {
+        const { summary, decisions, filesChanged, relatedPlan, branch } = args;
+        const sessionsPath = ensureSessionsDir(context.worktree);
+        const datePrefix = getDatePrefix();
+        const sessionId = generateSessionId();
+        const filename = `${datePrefix}-${sessionId}.md`;
+        const filepath = path.join(sessionsPath, filename);
+        // Get current branch if not provided
+        let currentBranch = branch;
+        if (!currentBranch) {
+            try {
+                currentBranch = (await Bun.$ `git branch --show-current`.cwd(context.worktree).text()).trim();
+            }
+            catch {
+                currentBranch = "unknown";
+            }
+        }
+        // Build content
+        let content = `---
+date: ${new Date().toISOString()}
+branch: ${currentBranch}
+${relatedPlan ? `relatedPlan: ${relatedPlan}` : ""}
+---
+
+# Session Summary
+
+${summary}
+
+## Key Decisions
+
+${decisions.map((d) => `- ${d}`).join("\n")}
+`;
+        if (filesChanged && filesChanged.length > 0) {
+            content += `
+## Files Changed
+
+${filesChanged.map((f) => `- \`${f}\``).join("\n")}
+`;
+        }
+        if (relatedPlan) {
+            content += `
+## Related Plan
+
+See: \`.cortex/plans/${relatedPlan}\`
+`;
+        }
+        // Write file
+        fs.writeFileSync(filepath, content);
+        return `✓ Session summary saved
+
+File: ${filename}
+Branch: ${currentBranch}
+Decisions recorded: ${decisions.length}
+${filesChanged ? `Files tracked: ${filesChanged.length}` : ""}
+
+Session summaries are stored in .cortex/sessions/ and gitignored by default.`;
+    },
+});
+export const list = tool({
+    description: "List recent session summaries from .cortex/sessions/",
+    args: {
+        limit: tool.schema
+            .number()
+            .optional()
+            .describe("Maximum number of sessions to return (default: 10)"),
+    },
+    async execute(args, context) {
+        const { limit = 10 } = args;
+        const sessionsPath = path.join(context.worktree, CORTEX_DIR, SESSIONS_DIR);
+        if (!fs.existsSync(sessionsPath)) {
+            return `No sessions found. The .cortex/sessions/ directory doesn't exist.
+
+Sessions are created when you use session_save after completing work.`;
+        }
+        const files = fs
+            .readdirSync(sessionsPath)
+            .filter((f) => f.endsWith(".md"))
+            .sort()
+            .reverse()
+            .slice(0, limit);
+        if (files.length === 0) {
+            return "No session summaries found in .cortex/sessions/";
+        }
+        let output = `📝 Recent Sessions (showing ${files.length}):\n\n`;
+        for (const file of files) {
+            const filepath = path.join(sessionsPath, file);
+            const content = fs.readFileSync(filepath, "utf-8");
+            // Parse frontmatter
+            let date = file.substring(0, 10);
+            let branch = "unknown";
+            const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+            if (frontmatterMatch) {
+                const fm = frontmatterMatch[1];
+                const dateMatch = fm.match(/date:\s*(\S+)/);
+                const branchMatch = fm.match(/branch:\s*(\S+)/);
+                if (dateMatch)
+                    date = dateMatch[1].split("T")[0];
+                if (branchMatch)
+                    branch = branchMatch[1];
+            }
+            // Get first line of summary (after frontmatter and heading)
+            const summaryMatch = content.match(/# Session Summary\n\n([^\n]+)/);
+            const summaryPreview = summaryMatch
+                ? summaryMatch[1].substring(0, 80) + (summaryMatch[1].length > 80 ? "..." : "")
+                : "(no summary)";
+            output += `• ${date} [${branch}]\n`;
+            output += `  ${summaryPreview}\n`;
+            output += `  File: ${file}\n\n`;
+        }
+        return output.trim();
+    },
+});
+export const load = tool({
+    description: "Load a session summary by filename",
+    args: {
+        filename: tool.schema.string().describe("Session filename"),
+    },
+    async execute(args, context) {
+        const { filename } = args;
+        const sessionsPath = path.join(context.worktree, CORTEX_DIR, SESSIONS_DIR);
+        const filepath = path.join(sessionsPath, filename);
+        if (!fs.existsSync(filepath)) {
+            return `✗ Session not found: ${filename}
+
+Use session_list to see available sessions.`;
+        }
+        const content = fs.readFileSync(filepath, "utf-8");
+        return `📝 Session: ${filename}
+${"=".repeat(50)}
+
+${content}`;
+    },
+});

package/dist/tools/worktree.d.ts

@@ -0,0 +1,45 @@
+export declare const create: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        type: import("zod").ZodEnum<{
+            feature: "feature";
+            bugfix: "bugfix";
+            hotfix: "hotfix";
+            refactor: "refactor";
+            spike: "spike";
+            docs: "docs";
+            test: "test";
+        }>;
+    };
+    execute(args: {
+        name: string;
+        type: "feature" | "bugfix" | "hotfix" | "refactor" | "spike" | "docs" | "test";
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const list: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const remove: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        deleteBranch: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        name: string;
+        deleteBranch?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const open: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+    };
+    execute(args: {
+        name: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+//# sourceMappingURL=worktree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../src/tools/worktree.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;CA8DjB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;CAiCf,CAAC;AAEH,eAAO,MAAM,MAAM;;;;;;;;;;CA4DjB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CAgDf,CAAC"}

package/dist/tools/worktree.js

@@ -0,0 +1,198 @@
+import { tool } from "@opencode-ai/plugin";
+import * as fs from "fs";
+import * as path from "path";
+const WORKTREE_ROOT = "../.worktrees";
+export const create = tool({
+    description: "Create a new git worktree for isolated development. Worktrees are created in ../.worktrees/",
+    args: {
+        name: tool.schema
+            .string()
+            .describe("Worktree name (e.g., 'auth-feature', 'login-bugfix')"),
+        type: tool.schema
+            .enum(["feature", "bugfix", "hotfix", "refactor", "spike", "docs", "test"])
+            .describe("Type of work - determines branch prefix"),
+    },
+    async execute(args, context) {
+        const { name, type } = args;
+        const branchName = `${type}/${name}`;
+        const worktreePath = path.join(context.worktree, WORKTREE_ROOT, name);
+        const absoluteWorktreePath = path.resolve(worktreePath);
+        // Check if we're in a git repository
+        try {
+            const gitCheck = await Bun.$ `git rev-parse --git-dir`.cwd(context.worktree).text();
+            if (!gitCheck.trim()) {
+                return "✗ Error: Not in a git repository";
+            }
+        }
+        catch {
+            return "✗ Error: Not in a git repository. Initialize git first.";
+        }
+        // Check if worktree already exists
+        if (fs.existsSync(absoluteWorktreePath)) {
+            return `✗ Error: Worktree already exists at ${absoluteWorktreePath}
+
+Use worktree_list to see existing worktrees.`;
+        }
+        // Create parent directory if needed
+        const worktreeParent = path.dirname(absoluteWorktreePath);
+        if (!fs.existsSync(worktreeParent)) {
+            fs.mkdirSync(worktreeParent, { recursive: true });
+        }
+        // Create the worktree with a new branch
+        try {
+            await Bun.$ `git worktree add -b ${branchName} ${absoluteWorktreePath}`.cwd(context.worktree);
+        }
+        catch (error) {
+            // Branch might already exist, try without -b
+            try {
+                await Bun.$ `git worktree add ${absoluteWorktreePath} ${branchName}`.cwd(context.worktree);
+            }
+            catch (error2) {
+                return `✗ Error creating worktree: ${error2.message || error2}`;
+            }
+        }
+        return `✓ Created worktree successfully
+
+Branch: ${branchName}
+Path: ${absoluteWorktreePath}
+
+To work in this worktree:
+  cd ${absoluteWorktreePath}
+
+Or use worktree_open to get a command to open a new terminal there.`;
+    },
+});
+export const list = tool({
+    description: "List all git worktrees for this project",
+    args: {},
+    async execute(args, context) {
+        try {
+            const result = await Bun.$ `git worktree list`.cwd(context.worktree).text();
+            if (!result.trim()) {
+                return "No worktrees found.";
+            }
+            const lines = result.trim().split("\n");
+            let output = "Git Worktrees:\n\n";
+            for (const line of lines) {
+                const parts = line.split(/\s+/);
+                const worktreePath = parts[0];
+                const commit = parts[1];
+                const branch = parts[2]?.replace(/[\[\]]/g, "") || "detached";
+                const isMain = worktreePath === context.worktree;
+                const marker = isMain ? " (main)" : "";
+                output += `• ${branch}${marker}\n`;
+                output += `  Path: ${worktreePath}\n`;
+                output += `  Commit: ${commit}\n\n`;
+            }
+            return output.trim();
+        }
+        catch (error) {
+            return `✗ Error listing worktrees: ${error.message || error}`;
+        }
+    },
+});
+export const remove = tool({
+    description: "Remove a git worktree (after merging). Optionally deletes the branch.",
+    args: {
+        name: tool.schema.string().describe("Worktree name to remove"),
+        deleteBranch: tool.schema
+            .boolean()
+            .optional()
+            .describe("Also delete the associated branch (default: false)"),
+    },
+    async execute(args, context) {
+        const { name, deleteBranch = false } = args;
+        const worktreePath = path.join(context.worktree, WORKTREE_ROOT, name);
+        const absoluteWorktreePath = path.resolve(worktreePath);
+        // Check if worktree exists
+        if (!fs.existsSync(absoluteWorktreePath)) {
+            return `✗ Error: Worktree not found at ${absoluteWorktreePath}
+
+Use worktree_list to see existing worktrees.`;
+        }
+        // Get branch name before removing
+        let branchName = "";
+        try {
+            branchName = await Bun.$ `git -C ${absoluteWorktreePath} branch --show-current`.text();
+            branchName = branchName.trim();
+        }
+        catch {
+            // Ignore error, branch detection is optional
+        }
+        // Remove the worktree
+        try {
+            await Bun.$ `git worktree remove ${absoluteWorktreePath}`.cwd(context.worktree);
+        }
+        catch (error) {
+            // Try force remove if there are changes
+            try {
+                await Bun.$ `git worktree remove --force ${absoluteWorktreePath}`.cwd(context.worktree);
+            }
+            catch (error2) {
+                return `✗ Error removing worktree: ${error2.message || error2}
+
+The worktree may have uncommitted changes. Commit or stash them first.`;
+            }
+        }
+        let output = `✓ Removed worktree at ${absoluteWorktreePath}`;
+        // Delete branch if requested
+        if (deleteBranch && branchName) {
+            try {
+                await Bun.$ `git branch -d ${branchName}`.cwd(context.worktree);
+                output += `\n✓ Deleted branch ${branchName}`;
+            }
+            catch (error) {
+                output += `\n⚠ Could not delete branch ${branchName}: ${error.message || error}`;
+                output += "\n  (Branch may not be fully merged. Use git branch -D to force delete.)";
+            }
+        }
+        return output;
+    },
+});
+export const open = tool({
+    description: "Get the command to open a new terminal window in a worktree directory",
+    args: {
+        name: tool.schema.string().describe("Worktree name"),
+    },
+    async execute(args, context) {
+        const { name } = args;
+        const worktreePath = path.join(context.worktree, WORKTREE_ROOT, name);
+        const absoluteWorktreePath = path.resolve(worktreePath);
+        // Check if worktree exists
+        if (!fs.existsSync(absoluteWorktreePath)) {
+            return `✗ Error: Worktree not found at ${absoluteWorktreePath}
+
+Use worktree_list to see existing worktrees.`;
+        }
+        // Detect OS and provide appropriate command
+        const platform = process.platform;
+        let command = "";
+        let instructions = "";
+        if (platform === "darwin") {
+            // macOS
+            command = `open -a Terminal "${absoluteWorktreePath}"`;
+            instructions = `Or with iTerm2: open -a iTerm "${absoluteWorktreePath}"`;
+        }
+        else if (platform === "linux") {
+            // Linux - try common terminals
+            command = `gnome-terminal --working-directory="${absoluteWorktreePath}" || xterm -e "cd '${absoluteWorktreePath}' && $SHELL" || konsole --workdir "${absoluteWorktreePath}"`;
+            instructions = "Command tries gnome-terminal, xterm, then konsole.";
+        }
+        else if (platform === "win32") {
+            // Windows
+            command = `start cmd /k "cd /d ${absoluteWorktreePath}"`;
+            instructions = `Or with PowerShell: Start-Process powershell -ArgumentList "-NoExit", "-Command", "cd '${absoluteWorktreePath}'"`;
+        }
+        else {
+            command = `cd "${absoluteWorktreePath}"`;
+            instructions = "Unknown platform. Use the cd command above.";
+        }
+        return `To open a new terminal in the worktree:
+
+${command}
+
+${instructions}
+
+Worktree path: ${absoluteWorktreePath}`;
+    },
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "cortex-agents",
+  "version": "1.0.0",
+  "description": "Cortex agents for OpenCode - worktree workflow, plan persistence, and session management",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "cortex-agents": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    ".opencode"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "postinstall": "echo 'Run: npx cortex-agents install'"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "cortex",
+    "agents",
+    "skills",
+    "ai",
+    "coding",
+    "worktree",
+    "git",
+    "planning"
+  ],
+  "author": "",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-org/cortex-agents"
+  },
+  "homepage": "https://github.com/your-org/cortex-agents#readme",
+  "bugs": {
+    "url": "https://github.com/your-org/cortex-agents/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "^1.0.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.0.0",
+    "@types/bun": "^1.3.9",
+    "@types/node": "^20.0.0",
+    "bun-types": "^1.0.0",
+    "typescript": "^5.0.0"
+  }
+}