@corbat-tech/coco 1.2.3 → 1.4.0

package/dist/index.js

@@ -117,6 +117,8 @@ function getApiKey(provider) {
       return process.env["KIMI_API_KEY"] ?? process.env["MOONSHOT_API_KEY"];
     case "lmstudio":
       return process.env["LMSTUDIO_API_KEY"] ?? "lm-studio";
+    case "ollama":
+      return process.env["OLLAMA_API_KEY"] ?? "ollama";
     case "codex":
       return void 0;
     default:
@@ -133,6 +135,8 @@ function getBaseUrl(provider) {
       return process.env["KIMI_BASE_URL"] ?? "https://api.moonshot.ai/v1";
     case "lmstudio":
       return process.env["LMSTUDIO_BASE_URL"] ?? "http://localhost:1234/v1";
+    case "ollama":
+      return process.env["OLLAMA_BASE_URL"] ?? "http://localhost:11434/v1";
     case "codex":
       return "https://chatgpt.com/backend-api/codex/responses";
     default:
@@ -144,22 +148,24 @@ function getDefaultModel(provider) {
     case "anthropic":
       return process.env["ANTHROPIC_MODEL"] ?? "claude-opus-4-6-20260115";
     case "openai":
-      return process.env["OPENAI_MODEL"] ?? "gpt-5.2-codex";
+      return process.env["OPENAI_MODEL"] ?? "gpt-5.3-codex";
     case "gemini":
       return process.env["GEMINI_MODEL"] ?? "gemini-3-flash-preview";
     case "kimi":
       return process.env["KIMI_MODEL"] ?? "kimi-k2.5";
     case "lmstudio":
       return process.env["LMSTUDIO_MODEL"] ?? "local-model";
+    case "ollama":
+      return process.env["OLLAMA_MODEL"] ?? "llama3.1";
     case "codex":
-      return process.env["CODEX_MODEL"] ?? "gpt-5.2-codex";
+      return process.env["CODEX_MODEL"] ?? "gpt-5.3-codex";
     default:
-      return "gpt-5.2-codex";
+      return "gpt-5.3-codex";
   }
 }
 function getDefaultProvider() {
   const provider = process.env["COCO_PROVIDER"]?.toLowerCase();
-  if (provider && ["anthropic", "openai", "codex", "gemini", "kimi", "lmstudio"].includes(provider)) {
+  if (provider && ["anthropic", "openai", "codex", "gemini", "kimi", "lmstudio", "ollama"].includes(provider)) {
     return provider;
   }
   return "anthropic";
@@ -3894,10 +3900,10 @@ var CoverageAnalyzer = class {
       join(this.projectPath, ".coverage", "coverage-summary.json"),
       join(this.projectPath, "coverage", "lcov-report", "coverage-summary.json")
     ];
-    for (const path36 of possiblePaths) {
+    for (const path37 of possiblePaths) {
       try {
-        await access(path36, constants.R_OK);
-        const content = await readFile(path36, "utf-8");
+        await access(path37, constants.R_OK);
+        const content = await readFile(path37, "utf-8");
         const report = JSON.parse(content);
         return parseCoverageSummary(report);
       } catch {
@@ -10326,7 +10332,7 @@ function createAnthropicProvider(config) {
   }
   return provider;
 }
-var DEFAULT_MODEL2 = "gpt-5.2-codex";
+var DEFAULT_MODEL2 = "gpt-5.3-codex";
 var CONTEXT_WINDOWS2 = {
   // OpenAI models
   "gpt-4o": 128e3,
@@ -10337,6 +10343,10 @@ var CONTEXT_WINDOWS2 = {
   o1: 2e5,
   "o1-mini": 128e3,
   "o3-mini": 2e5,
+  "o4-mini": 2e5,
+  // GPT-4.1 series (Feb 2026)
+  "gpt-4.1": 1048576,
+  "gpt-4.1-mini": 1048576,
   // GPT-5 series (2025-2026)
   "gpt-5": 4e5,
   "gpt-5.2": 4e5,
@@ -10344,6 +10354,7 @@ var CONTEXT_WINDOWS2 = {
   "gpt-5.2-thinking": 4e5,
   "gpt-5.2-instant": 4e5,
   "gpt-5.2-pro": 4e5,
+  "gpt-5.3-codex": 4e5,
   // Kimi/Moonshot models
   "kimi-k2.5": 262144,
   "kimi-k2-0324": 131072,
@@ -11139,10 +11150,11 @@ async function getCachedADCToken() {
 
 // src/providers/codex.ts
 var CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
-var DEFAULT_MODEL3 = "gpt-5.2-codex";
+var DEFAULT_MODEL3 = "gpt-5.3-codex";
 var CONTEXT_WINDOWS3 = {
-  "gpt-5-codex": 2e5,
+  "gpt-5.3-codex": 2e5,
   "gpt-5.2-codex": 2e5,
+  "gpt-5-codex": 2e5,
   "gpt-5.1-codex": 2e5,
   "gpt-5": 2e5,
   "gpt-5.2": 2e5,
@@ -11890,6 +11902,11 @@ async function createProvider(type, config = {}) {
       mergedConfig.baseUrl = mergedConfig.baseUrl ?? "http://localhost:1234/v1";
       mergedConfig.apiKey = mergedConfig.apiKey ?? "lm-studio";
       break;
+    case "ollama":
+      provider = new OpenAIProvider();
+      mergedConfig.baseUrl = mergedConfig.baseUrl ?? "http://localhost:11434/v1";
+      mergedConfig.apiKey = mergedConfig.apiKey ?? "ollama";
+      break;
     default:
       throw new ProviderError(`Unknown provider type: ${type}`, {
         provider: type
@@ -12011,9 +12028,9 @@ function createInitialState(config) {
 }
 async function loadExistingState(projectPath) {
   try {
-    const fs35 = await import('fs/promises');
+    const fs36 = await import('fs/promises');
     const statePath = `${projectPath}/.coco/state/project.json`;
-    const content = await fs35.readFile(statePath, "utf-8");
+    const content = await fs36.readFile(statePath, "utf-8");
     const data = JSON.parse(content);
     data.createdAt = new Date(data.createdAt);
     data.updatedAt = new Date(data.updatedAt);
@@ -12023,13 +12040,13 @@ async function loadExistingState(projectPath) {
   }
 }
 async function saveState(state) {
-  const fs35 = await import('fs/promises');
+  const fs36 = await import('fs/promises');
   const statePath = `${state.path}/.coco/state`;
-  await fs35.mkdir(statePath, { recursive: true });
+  await fs36.mkdir(statePath, { recursive: true });
   const filePath = `${statePath}/project.json`;
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
-  await fs35.writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
-  await fs35.rename(tmpPath, filePath);
+  await fs36.writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+  await fs36.rename(tmpPath, filePath);
 }
 function getPhaseExecutor(phase) {
   switch (phase) {
@@ -12088,20 +12105,20 @@ async function createPhaseContext(config, state) {
   };
   const tools = {
     file: {
-      async read(path36) {
-        const fs35 = await import('fs/promises');
-        return fs35.readFile(path36, "utf-8");
+      async read(path37) {
+        const fs36 = await import('fs/promises');
+        return fs36.readFile(path37, "utf-8");
       },
-      async write(path36, content) {
-        const fs35 = await import('fs/promises');
+      async write(path37, content) {
+        const fs36 = await import('fs/promises');
         const nodePath = await import('path');
-        await fs35.mkdir(nodePath.dirname(path36), { recursive: true });
-        await fs35.writeFile(path36, content, "utf-8");
+        await fs36.mkdir(nodePath.dirname(path37), { recursive: true });
+        await fs36.writeFile(path37, content, "utf-8");
       },
-      async exists(path36) {
-        const fs35 = await import('fs/promises');
+      async exists(path37) {
+        const fs36 = await import('fs/promises');
         try {
-          await fs35.access(path36);
+          await fs36.access(path37);
           return true;
         } catch {
           return false;
@@ -12114,9 +12131,9 @@ async function createPhaseContext(config, state) {
     },
     bash: {
       async exec(command, options = {}) {
-        const { execa: execa9 } = await import('execa');
+        const { execa: execa11 } = await import('execa');
         try {
-          const result = await execa9(command, {
+          const result = await execa11(command, {
             shell: true,
             cwd: options.cwd || state.path,
             timeout: options.timeout,
@@ -12139,8 +12156,8 @@ async function createPhaseContext(config, state) {
     },
     git: {
       async status() {
-        const { execa: execa9 } = await import('execa');
-        const result = await execa9("git", ["status", "--porcelain", "-b"], { cwd: state.path });
+        const { execa: execa11 } = await import('execa');
+        const result = await execa11("git", ["status", "--porcelain", "-b"], { cwd: state.path });
         const lines = result.stdout.split("\n");
         const branchLine = lines[0] || "";
         const branch = branchLine.replace("## ", "").split("...")[0] || "main";
@@ -12153,24 +12170,24 @@ async function createPhaseContext(config, state) {
         };
       },
       async commit(message, files) {
-        const { execa: execa9 } = await import('execa');
+        const { execa: execa11 } = await import('execa');
         if (files && files.length > 0) {
-          await execa9("git", ["add", ...files], { cwd: state.path });
+          await execa11("git", ["add", ...files], { cwd: state.path });
         }
-        await execa9("git", ["commit", "-m", message], { cwd: state.path });
+        await execa11("git", ["commit", "-m", message], { cwd: state.path });
       },
       async push() {
-        const { execa: execa9 } = await import('execa');
-        await execa9("git", ["push"], { cwd: state.path });
+        const { execa: execa11 } = await import('execa');
+        await execa11("git", ["push"], { cwd: state.path });
       }
     },
     test: {
       async run(pattern) {
-        const { execa: execa9 } = await import('execa');
+        const { execa: execa11 } = await import('execa');
         try {
           const args = ["test", "--reporter=json"];
           if (pattern) args.push(pattern);
-          await execa9("pnpm", args, { cwd: state.path });
+          await execa11("pnpm", args, { cwd: state.path });
           return {
             passed: 0,
             failed: 0,
@@ -12250,9 +12267,9 @@ async function createSnapshot(state) {
 var MAX_CHECKPOINT_VERSIONS = 5;
 async function getCheckpointFiles(state, phase) {
   try {
-    const fs35 = await import('fs/promises');
+    const fs36 = await import('fs/promises');
     const checkpointDir = `${state.path}/.coco/checkpoints`;
-    const files = await fs35.readdir(checkpointDir);
+    const files = await fs36.readdir(checkpointDir);
     const phaseFiles = files.filter((f) => f.startsWith(`snapshot-pre-${phase}-`) && f.endsWith(".json")).sort((a, b) => {
       const tsA = parseInt(a.split("-").pop()?.replace(".json", "") ?? "0", 10);
       const tsB = parseInt(b.split("-").pop()?.replace(".json", "") ?? "0", 10);
@@ -12265,11 +12282,11 @@ async function getCheckpointFiles(state, phase) {
 }
 async function cleanupOldCheckpoints(state, phase) {
   try {
-    const fs35 = await import('fs/promises');
+    const fs36 = await import('fs/promises');
     const files = await getCheckpointFiles(state, phase);
     if (files.length > MAX_CHECKPOINT_VERSIONS) {
       const filesToDelete = files.slice(MAX_CHECKPOINT_VERSIONS);
-      await Promise.all(filesToDelete.map((f) => fs35.unlink(f).catch(() => {
+      await Promise.all(filesToDelete.map((f) => fs36.unlink(f).catch(() => {
       })));
     }
   } catch {
@@ -12277,13 +12294,13 @@ async function cleanupOldCheckpoints(state, phase) {
 }
 async function saveSnapshot(state, snapshotId) {
   try {
-    const fs35 = await import('fs/promises');
+    const fs36 = await import('fs/promises');
     const snapshotPath = `${state.path}/.coco/checkpoints/snapshot-${snapshotId}.json`;
     const snapshotDir = `${state.path}/.coco/checkpoints`;
-    await fs35.mkdir(snapshotDir, { recursive: true });
+    await fs36.mkdir(snapshotDir, { recursive: true });
     const createdAt = state.createdAt instanceof Date ? state.createdAt.toISOString() : String(state.createdAt);
     const updatedAt = state.updatedAt instanceof Date ? state.updatedAt.toISOString() : String(state.updatedAt);
-    await fs35.writeFile(
+    await fs36.writeFile(
       snapshotPath,
       JSON.stringify(
         {
@@ -12381,7 +12398,7 @@ function generateId() {
   return `proj_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 9)}`;
 }
 var ProviderConfigSchema = z.object({
-  type: z.enum(["anthropic", "openai", "gemini", "kimi"]).default("anthropic"),
+  type: z.enum(["anthropic", "openai", "gemini", "kimi", "lmstudio", "ollama"]).default("anthropic"),
   apiKey: z.string().optional(),
   model: z.string().default("claude-sonnet-4-20250514"),
   maxTokens: z.number().min(1).max(2e5).default(8192),
@@ -12469,6 +12486,22 @@ var ToolsConfigSchema = z.object({
     threshold: z.number().min(0).max(1).default(0.3)
   }).optional()
 });
+var ShipConfigSchema = z.object({
+  /** Default base branch for PRs */
+  defaultBaseBranch: z.string().default("main"),
+  /** Auto-detect version bump from commit history */
+  autoDetectBump: z.boolean().default(true),
+  /** Use squash merge for PRs */
+  squashMerge: z.boolean().default(true),
+  /** Delete feature branch after merge */
+  deleteBranchAfterMerge: z.boolean().default(true),
+  /** Create PRs as draft by default */
+  draftPr: z.boolean().default(false),
+  /** CI check timeout in ms (default 10 minutes) */
+  ciCheckTimeoutMs: z.number().default(6e5),
+  /** CI check poll interval in ms (default 15 seconds) */
+  ciCheckPollMs: z.number().default(15e3)
+});
 var CocoConfigSchema = z.object({
   project: ProjectConfigSchema,
   provider: ProviderConfigSchema.default({
@@ -12495,7 +12528,8 @@ var CocoConfigSchema = z.object({
   stack: StackConfigSchema.optional(),
   integrations: IntegrationsConfigSchema.optional(),
   mcp: MCPConfigSchema.optional(),
-  tools: ToolsConfigSchema.optional()
+  tools: ToolsConfigSchema.optional(),
+  ship: ShipConfigSchema.optional()
 });
 function createDefaultConfigObject(projectName, language = "typescript") {
   return {
@@ -16582,9 +16616,9 @@ async function fileExists(filePath) {
     return false;
   }
 }
-async function fileExists2(path36) {
+async function fileExists2(path37) {
   try {
-    await access(path36);
+    await access(path37);
     return true;
   } catch {
     return false;
@@ -16674,7 +16708,7 @@ async function detectMaturity(cwd) {
   if (!hasLintConfig && hasPackageJson) {
     try {
       const pkgRaw = await import('fs/promises').then(
-        (fs35) => fs35.readFile(join(cwd, "package.json"), "utf-8")
+        (fs36) => fs36.readFile(join(cwd, "package.json"), "utf-8")
       );
       const pkg = JSON.parse(pkgRaw);
       if (pkg.scripts?.lint || pkg.scripts?.["lint:fix"]) {
@@ -20128,6 +20162,351 @@ var recommendBranchTool = defineTool({
   }
 });
 var gitEnhancedTools = [analyzeRepoHealthTool, getCommitStatsTool, recommendBranchTool];
+async function ghExec(args, cwd) {
+  try {
+    const result = await execa("gh", args, {
+      cwd: cwd ?? process.cwd(),
+      timeout: 6e4
+    });
+    return { stdout: result.stdout, stderr: result.stderr };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new ToolError(`gh command failed: ${message}`, {
+      tool: "github",
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+var ghCheckAuthTool = defineTool({
+  name: "gh_check_auth",
+  description: "Check if the GitHub CLI is installed and authenticated.",
+  category: "git",
+  parameters: z.object({
+    cwd: z.string().optional()
+  }),
+  async execute({ cwd }) {
+    try {
+      const { stdout } = await ghExec(["auth", "status"], cwd);
+      const userMatch = stdout.match(/Logged in to .+ as (\S+)/);
+      return {
+        authenticated: true,
+        user: userMatch?.[1]
+      };
+    } catch {
+      return { authenticated: false, error: "gh CLI not authenticated. Run: gh auth login" };
+    }
+  }
+});
+var ghRepoInfoTool = defineTool({
+  name: "gh_repo_info",
+  description: "Get GitHub repository information (name, default branch, URL).",
+  category: "git",
+  parameters: z.object({
+    cwd: z.string().optional()
+  }),
+  async execute({ cwd }) {
+    const { stdout } = await ghExec(
+      ["repo", "view", "--json", "name,nameWithOwner,defaultBranchRef,url,isPrivate"],
+      cwd
+    );
+    const data = JSON.parse(stdout);
+    return {
+      name: data.name,
+      fullName: data.nameWithOwner,
+      defaultBranch: data.defaultBranchRef.name,
+      url: data.url,
+      private: data.isPrivate
+    };
+  }
+});
+var ghPrCreateTool = defineTool({
+  name: "gh_pr_create",
+  description: "Create a GitHub pull request.",
+  category: "git",
+  parameters: z.object({
+    title: z.string().describe("PR title"),
+    body: z.string().describe("PR body (markdown)"),
+    base: z.string().optional().describe("Base branch (default: repo default)"),
+    draft: z.boolean().optional().default(false),
+    cwd: z.string().optional()
+  }),
+  async execute({ title, body, base, draft, cwd }) {
+    const args = ["pr", "create", "--title", title, "--body", body];
+    if (base) args.push("--base", base);
+    if (draft) args.push("--draft");
+    const { stdout } = await ghExec(args, cwd);
+    const url = stdout.trim();
+    const numberMatch = url.match(/\/pull\/(\d+)/);
+    return {
+      number: numberMatch ? parseInt(numberMatch[1], 10) : 0,
+      url
+    };
+  }
+});
+var ghPrMergeTool = defineTool({
+  name: "gh_pr_merge",
+  description: "Merge a GitHub pull request.",
+  category: "git",
+  parameters: z.object({
+    number: z.number().describe("PR number"),
+    method: z.enum(["squash", "merge", "rebase"]).optional().default("squash"),
+    deleteBranch: z.boolean().optional().default(true),
+    subject: z.string().optional().describe("Merge commit subject line"),
+    body: z.string().optional().describe("Merge commit body"),
+    cwd: z.string().optional()
+  }),
+  async execute({ number, method, deleteBranch, subject, body, cwd }) {
+    const args = ["pr", "merge", String(number), `--${method}`];
+    if (deleteBranch) args.push("--delete-branch");
+    if (subject) args.push("--subject", subject);
+    if (body) args.push("--body", body);
+    await ghExec(args, cwd);
+    return { merged: true, method };
+  }
+});
+var ghPrChecksTool = defineTool({
+  name: "gh_pr_checks",
+  description: "Get CI check statuses for a pull request.",
+  category: "git",
+  parameters: z.object({
+    number: z.number().describe("PR number"),
+    cwd: z.string().optional()
+  }),
+  async execute({ number, cwd }) {
+    const { stdout } = await ghExec(
+      ["pr", "checks", String(number), "--json", "name,state,conclusion,detailsUrl"],
+      cwd
+    );
+    const raw = JSON.parse(stdout);
+    const checks = raw.map((c) => {
+      let status = "pending";
+      if (c.state === "SUCCESS" || c.conclusion === "SUCCESS") status = "pass";
+      else if (c.state === "FAILURE" || c.conclusion === "FAILURE") status = "fail";
+      else if (c.state === "SKIPPED" || c.conclusion === "SKIPPED") status = "skipping";
+      return {
+        name: c.name,
+        status,
+        conclusion: c.conclusion || c.state,
+        url: c.detailsUrl
+      };
+    });
+    return {
+      checks,
+      allPassed: checks.length > 0 && checks.every((c) => c.status === "pass" || c.status === "skipping"),
+      anyFailed: checks.some((c) => c.status === "fail"),
+      anyPending: checks.some((c) => c.status === "pending")
+    };
+  }
+});
+var ghPrListTool = defineTool({
+  name: "gh_pr_list",
+  description: "List pull requests, optionally filtered by head branch.",
+  category: "git",
+  parameters: z.object({
+    head: z.string().optional().describe("Filter by head branch name"),
+    state: z.string().optional().default("open"),
+    cwd: z.string().optional()
+  }),
+  async execute({ head, state, cwd }) {
+    const args = ["pr", "list", "--json", "number,title,url,state", "--state", state];
+    if (head) args.push("--head", head);
+    const { stdout } = await ghExec(args, cwd);
+    const raw = JSON.parse(stdout);
+    return { prs: raw };
+  }
+});
+var ghReleaseCreateTool = defineTool({
+  name: "gh_release_create",
+  description: "Create a GitHub release with notes.",
+  category: "git",
+  parameters: z.object({
+    tag: z.string().describe("Tag name (e.g., v1.2.3)"),
+    title: z.string().optional().describe("Release title"),
+    notes: z.string().optional().describe("Release notes (markdown)"),
+    draft: z.boolean().optional().default(false),
+    prerelease: z.boolean().optional().default(false),
+    cwd: z.string().optional()
+  }),
+  async execute({ tag, title, notes, draft, prerelease, cwd }) {
+    const args = ["release", "create", tag];
+    if (title) args.push("--title", title);
+    if (notes) args.push("--notes", notes);
+    if (draft) args.push("--draft");
+    if (prerelease) args.push("--prerelease");
+    const { stdout } = await ghExec(args, cwd);
+    return { url: stdout.trim(), tag };
+  }
+});
+var githubTools = [
+  ghCheckAuthTool,
+  ghRepoInfoTool,
+  ghPrCreateTool,
+  ghPrMergeTool,
+  ghPrChecksTool,
+  ghPrListTool,
+  ghReleaseCreateTool
+];
+var INTERPRETER_MAP = {
+  ".py": ["python3"],
+  ".sh": ["bash"],
+  ".bash": ["bash"],
+  ".zsh": ["zsh"],
+  ".js": ["node"],
+  ".ts": ["npx", "tsx"],
+  ".rb": ["ruby"],
+  ".pl": ["perl"],
+  ".lua": ["lua"],
+  ".php": ["php"]
+};
+var BLOCKED_PATHS2 = ["/etc", "/var", "/usr", "/root", "/sys", "/proc", "/boot", "/dev"];
+var BLOCKED_EXEC_PATTERNS = [
+  /\.env(?:\.\w+)?$/,
+  /\.pem$/,
+  /\.key$/,
+  /id_rsa/,
+  /credentials\.\w+$/i,
+  /secrets?\.\w+$/i
+];
+var DANGEROUS_ARG_PATTERNS = [
+  /\brm\s+-rf\s+\/(?!\w)/,
+  /\bsudo\s+rm/,
+  /\bdd\s+if=.*of=\/dev\//,
+  /`[^`]+`/,
+  /\$\([^)]+\)/,
+  /\beval\s+/,
+  /\bcurl\s+.*\|\s*(ba)?sh/
+];
+function getSystemOpenCommand() {
+  return process.platform === "darwin" ? "open" : "xdg-open";
+}
+function hasNullByte2(str) {
+  return str.includes("\0");
+}
+function isBlockedPath(absolute) {
+  for (const blocked of BLOCKED_PATHS2) {
+    const normalizedBlocked = path14__default.normalize(blocked);
+    if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path14__default.sep)) {
+      return blocked;
+    }
+  }
+  return void 0;
+}
+function isBlockedExecFile(filePath) {
+  return BLOCKED_EXEC_PATTERNS.some((p4) => p4.test(filePath));
+}
+function hasDangerousArgs(args) {
+  const joined = args.join(" ");
+  return DANGEROUS_ARG_PATTERNS.some((p4) => p4.test(joined));
+}
+function getInterpreter(ext) {
+  return INTERPRETER_MAP[ext.toLowerCase()];
+}
+async function isExecutable(filePath) {
+  try {
+    await fs14__default.access(filePath, fs14__default.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var openFileTool = defineTool({
+  name: "open_file",
+  description: `Open a file with the system application or execute a script/binary.
+
+Mode "open" (default): Opens the file with the OS default application.
+- HTML files \u2192 browser
+- Images \u2192 image viewer
+- PDFs \u2192 PDF reader
+- Directories \u2192 file manager
+
+Mode "exec": Executes a script or binary.
+- .py \u2192 python3, .sh \u2192 bash, .js \u2192 node, .ts \u2192 npx tsx
+- .rb \u2192 ruby, .pl \u2192 perl, .lua \u2192 lua, .php \u2192 php
+- Binaries with +x permissions \u2192 direct execution
+
+Examples:
+- Open in browser: { "path": "docs/index.html" }
+- View image: { "path": "screenshot.png" }
+- Run script: { "path": "scripts/setup.sh", "mode": "exec" }
+- Run with args: { "path": "deploy.py", "mode": "exec", "args": ["--env", "staging"] }`,
+  category: "bash",
+  parameters: z.object({
+    path: z.string().describe("File path to open or execute"),
+    mode: z.enum(["open", "exec"]).optional().default("open").describe("open = system app, exec = run script"),
+    args: z.array(z.string()).optional().default([]).describe("Arguments for exec mode"),
+    cwd: z.string().optional().describe("Working directory"),
+    timeout: z.number().optional().describe("Timeout in ms for exec mode (default 120000)")
+  }),
+  async execute({ path: filePath, mode = "open", args = [], cwd, timeout }) {
+    const start = performance.now();
+    if (!filePath || hasNullByte2(filePath)) {
+      throw new ToolError("Invalid file path", { tool: "open_file" });
+    }
+    const workDir = cwd ?? process.cwd();
+    const absolute = path14__default.isAbsolute(filePath) ? path14__default.normalize(filePath) : path14__default.resolve(workDir, filePath);
+    const blockedBy = isBlockedPath(absolute);
+    if (blockedBy) {
+      throw new ToolError(`Access to system path '${blockedBy}' is not allowed`, {
+        tool: "open_file"
+      });
+    }
+    try {
+      await fs14__default.access(absolute);
+    } catch {
+      throw new ToolError(`File not found: ${absolute}`, { tool: "open_file" });
+    }
+    if (mode === "open") {
+      const cmd = getSystemOpenCommand();
+      await execa(cmd, [absolute], { timeout: 1e4 });
+      return {
+        action: "opened",
+        path: absolute,
+        resolvedCommand: cmd,
+        duration: performance.now() - start
+      };
+    }
+    if (isBlockedExecFile(absolute)) {
+      throw new ToolError(`Execution of sensitive file is blocked: ${path14__default.basename(absolute)}`, {
+        tool: "open_file"
+      });
+    }
+    if (args.length > 0 && hasDangerousArgs(args)) {
+      throw new ToolError("Arguments contain dangerous patterns", { tool: "open_file" });
+    }
+    const ext = path14__default.extname(absolute);
+    const interpreter = getInterpreter(ext);
+    const executable = await isExecutable(absolute);
+    let command;
+    let cmdArgs;
+    if (interpreter) {
+      command = interpreter[0];
+      cmdArgs = [...interpreter.slice(1), absolute, ...args];
+    } else if (executable) {
+      command = absolute;
+      cmdArgs = [...args];
+    } else {
+      throw new ToolError(
+        `Cannot execute '${path14__default.basename(absolute)}': no known interpreter for '${ext || "(no extension)"}' and file is not executable`,
+        { tool: "open_file" }
+      );
+    }
+    const result = await execa(command, cmdArgs, {
+      cwd: workDir,
+      timeout: timeout ?? 12e4,
+      reject: false
+    });
+    return {
+      action: "executed",
+      path: absolute,
+      resolvedCommand: interpreter ? interpreter.join(" ") : absolute,
+      stdout: result.stdout || void 0,
+      stderr: result.stderr || void 0,
+      exitCode: result.exitCode ?? 0,
+      duration: performance.now() - start
+    };
+  }
+});
+var openTools = [openFileTool];
 init_allowed_paths();
 var BLOCKED_SYSTEM_PATHS = [
   "/etc",
@@ -20259,6 +20638,8 @@ function registerAllTools(registry) {
     ...contextEnhancerTools,
     ...skillEnhancerTools,
     ...gitEnhancedTools,
+    ...githubTools,
+    ...openTools,
     ...authorizePathTools
   ];
   for (const tool of allTools) {