@hasna/terminal 3.5.0 → 3.7.0

package/dist/mcp/server.js

@@ -153,7 +153,7 @@ export function createServer() {
         return { content: [{ type: "text", text: output }] };
     });
     // ── execute_smart: AI-powered output processing ────────────────────────────
-    server.tool("execute_smart", "Run a command and get AI-summarized output. The AI decides what's important — errors, failures, key results are kept; verbose logs, progress bars, passing tests are dropped. Saves 80-95% tokens vs raw output. Best tool for agents.", {
+    server.tool("execute_smart", "Run a command and get AI-summarized output (80-95% token savings). Use this for: test runs, builds, git operations, process management, system info. Do NOT use for file read/write — use your native Read/Write/Edit tools instead (they're faster, no shell overhead).", {
         command: z.string().describe("Shell command to execute"),
         cwd: z.string().optional().describe("Working directory"),
         timeout: z.number().optional().describe("Timeout in ms (default: 30000)"),
@@ -478,7 +478,7 @@ export function createServer() {
         };
     });
     // ── read_file: cached file reading ─────────────────────────────────────────
-    server.tool("read_file", "Read a file with session caching. Use summarize=true to get an AI-generated outline (~90% fewer tokens) instead of full content — ideal when you just want to understand what a file does without reading every line.", {
+    server.tool("read_file", "Read a file with summarize=true for AI outline (~90% fewer tokens). For full file reads without summarization, prefer your native Read tool (faster, no MCP overhead). Use this when you want cached reads or AI summaries.", {
         path: z.string().describe("File path"),
         offset: z.number().optional().describe("Start line (0-indexed)"),
         limit: z.number().optional().describe("Max lines to return"),
@@ -620,6 +620,140 @@ Match by function name, class name, method name (including ClassName.method), in
         logCall("read_symbol", { command: `${filePath}:${name}`, outputTokens: estimateTokens(result.content), tokensSaved: Math.max(0, estimateTokens(result.content) - estimateTokens(JSON.stringify(parsed))), durationMs: Date.now() - start, aiProcessed: true });
         return { content: [{ type: "text", text: JSON.stringify(parsed) }] };
     });
+    // ── Intent-level tools — agents express WHAT, we handle HOW ───────────────
+    server.tool("commit", "Commit and optionally push. Agent says what to commit, we handle git add/commit/push. Saves ~400 tokens vs raw git commands.", {
+        message: z.string().describe("Commit message"),
+        files: z.array(z.string()).optional().describe("Files to stage (default: all changed)"),
+        push: z.boolean().optional().describe("Push after commit (default: false)"),
+        cwd: z.string().optional().describe("Working directory"),
+    }, async ({ message, files, push, cwd }) => {
+        const start = Date.now();
+        const workDir = cwd ?? process.cwd();
+        const addCmd = files && files.length > 0 ? `git add ${files.map(f => `"${f}"`).join(" ")}` : "git add -A";
+        const commitCmd = `${addCmd} && git commit -m ${JSON.stringify(message)}`;
+        const fullCmd = push ? `${commitCmd} && git push` : commitCmd;
+        const result = await exec(fullCmd, workDir, 30000);
+        const output = (result.stdout + result.stderr).trim();
+        logCall("commit", { command: `commit: ${message.slice(0, 80)}`, durationMs: Date.now() - start, exitCode: result.exitCode });
+        invalidateBootCache();
+        return { content: [{ type: "text", text: JSON.stringify({
+                        exitCode: result.exitCode,
+                        output: stripAnsi(output).split("\n").filter(l => l.trim()).slice(0, 5).join("\n"),
+                        pushed: push ?? false,
+                    }) }] };
+    });
+    server.tool("run", "Run a project task by intent — test, build, lint, dev, typecheck, format. Auto-detects toolchain (bun/npm/pnpm/yarn/cargo/go/make). Saves ~100 tokens vs raw commands.", {
+        task: z.enum(["test", "build", "lint", "dev", "start", "typecheck", "format", "check"]).describe("What to run"),
+        args: z.string().optional().describe("Extra arguments (e.g., '--watch', 'src/foo.test.ts')"),
+        cwd: z.string().optional().describe("Working directory"),
+    }, async ({ task, args, cwd }) => {
+        const start = Date.now();
+        const workDir = cwd ?? process.cwd();
+        // Detect toolchain from project files
+        const { existsSync } = await import("fs");
+        const { join } = await import("path");
+        let runner = "npm run";
+        if (existsSync(join(workDir, "bun.lockb")) || existsSync(join(workDir, "bun.lock")))
+            runner = "bun run";
+        else if (existsSync(join(workDir, "pnpm-lock.yaml")))
+            runner = "pnpm run";
+        else if (existsSync(join(workDir, "yarn.lock")))
+            runner = "yarn";
+        else if (existsSync(join(workDir, "Cargo.toml")))
+            runner = "cargo";
+        else if (existsSync(join(workDir, "go.mod")))
+            runner = "go";
+        else if (existsSync(join(workDir, "Makefile")))
+            runner = "make";
+        // Map intent to command
+        let cmd;
+        if (runner === "cargo") {
+            cmd = `cargo ${task}${args ? ` ${args}` : ""}`;
+        }
+        else if (runner === "go") {
+            const goMap = { test: "go test ./...", build: "go build ./...", lint: "golangci-lint run", format: "gofmt -w .", check: "go vet ./..." };
+            cmd = goMap[task] ?? `go ${task}`;
+        }
+        else if (runner === "make") {
+            cmd = `make ${task}${args ? ` ${args}` : ""}`;
+        }
+        else {
+            // JS/TS ecosystem
+            const jsMap = { test: "test", build: "build", lint: "lint", dev: "dev", start: "start", typecheck: "typecheck", format: "format", check: "check" };
+            cmd = `${runner} ${jsMap[task] ?? task}${args ? ` ${args}` : ""}`;
+        }
+        const result = await exec(cmd, workDir, 120000);
+        const output = (result.stdout + result.stderr).trim();
+        const processed = await processOutput(cmd, output);
+        logCall("run", { command: `${task}${args ? ` ${args}` : ""}`, outputTokens: estimateTokens(output), tokensSaved: processed.tokensSaved, durationMs: Date.now() - start, exitCode: result.exitCode, aiProcessed: processed.aiProcessed });
+        return { content: [{ type: "text", text: JSON.stringify({
+                        exitCode: result.exitCode,
+                        task,
+                        runner,
+                        summary: processed.summary,
+                        tokensSaved: processed.tokensSaved,
+                    }) }] };
+    });
+    server.tool("edit", "Find and replace in a file. For simple edits, prefer your native Edit tool (faster). Use this for batch replacements (all=true) or when you don't have a native Edit tool available.", {
+        file: z.string().describe("File path"),
+        find: z.string().describe("Text to find (exact match)"),
+        replace: z.string().describe("Replacement text"),
+        all: z.boolean().optional().describe("Replace all occurrences (default: first only)"),
+    }, async ({ file, find, replace, all }) => {
+        const start = Date.now();
+        const { readFileSync, writeFileSync } = await import("fs");
+        try {
+            let content = readFileSync(file, "utf8");
+            const count = (content.match(new RegExp(find.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")) || []).length;
+            if (count === 0) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: "Text not found", file }) }] };
+            }
+            if (all) {
+                content = content.split(find).join(replace);
+            }
+            else {
+                content = content.replace(find, replace);
+            }
+            writeFileSync(file, content);
+            logCall("edit", { command: `edit ${file}`, durationMs: Date.now() - start });
+            return { content: [{ type: "text", text: JSON.stringify({ ok: true, file, replacements: all ? count : 1 }) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: e.message }) }] };
+        }
+    });
+    server.tool("lookup", "Search for specific items in a file by name or pattern. Agent says what to find, not how to grep. Saves ~300 tokens vs constructing grep pipelines.", {
+        file: z.string().describe("File path to search in"),
+        items: z.array(z.string()).describe("Names or patterns to look up"),
+        context: z.number().optional().describe("Lines of context around each match (default: 3)"),
+    }, async ({ file, items, context }) => {
+        const start = Date.now();
+        const { readFileSync } = await import("fs");
+        try {
+            const content = readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            const ctx = context ?? 3;
+            const results = {};
+            for (const item of items) {
+                results[item] = [];
+                const pattern = new RegExp(item.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+                for (let i = 0; i < lines.length; i++) {
+                    if (pattern.test(lines[i])) {
+                        results[item].push({
+                            line: i + 1,
+                            text: lines[i].trim(),
+                            context: lines.slice(Math.max(0, i - ctx), i + ctx + 1).map(l => l.trimEnd()),
+                        });
+                    }
+                }
+            }
+            logCall("lookup", { command: `lookup ${file} [${items.join(",")}]`, durationMs: Date.now() - start });
+            return { content: [{ type: "text", text: JSON.stringify(results) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: e.message }) }] };
+        }
+    });
     return server;
 }
 // ── main: start MCP server via stdio ─────────────────────────────────────────

package/dist/recipes/storage.js

@@ -24,14 +24,31 @@ function saveStore(filePath, store) {
         mkdirSync(dir, { recursive: true });
     writeFileSync(filePath, JSON.stringify(store, null, 2));
 }
+// ── Built-in system recipes (always available, zero config) ─────────────────
+const SYSTEM_RECIPES = [
+    // Git workflows
+    { id: "sys-commit-push", name: "commit-push", description: "Stage all, commit, push to origin", command: "git add -A && git commit -m \"{message}\" && git push", tags: ["git"], collection: "git", variables: [{ name: "message", required: true }], createdAt: 0, updatedAt: 0 },
+    { id: "sys-pr", name: "create-pr", description: "Create GitHub PR from current branch", command: "gh pr create --title \"{title}\" --body \"{body}\"", tags: ["git", "github"], collection: "git", variables: [{ name: "title", required: true }, { name: "body", default: "" }], createdAt: 0, updatedAt: 0 },
+    { id: "sys-stash", name: "stash-switch", description: "Stash changes, switch branch, pop", command: "git stash && git checkout {branch} && git stash pop", tags: ["git"], collection: "git", variables: [{ name: "branch", required: true }], createdAt: 0, updatedAt: 0 },
+    // Quality checks
+    { id: "sys-todos", name: "find-todos", description: "Find all TODO/FIXME/HACK in source code", command: "grep -rn 'TODO\\|FIXME\\|HACK\\|XXX' {path} --include='*.ts' --include='*.tsx' --include='*.js' --include='*.py' --include='*.go' --include='*.rs' --include='*.java' --include='*.rb'", tags: ["quality"], collection: "quality", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+    { id: "sys-deadcode", name: "find-unused-exports", description: "Find exported symbols that may be unused", command: "grep -rn 'export ' {path} --include='*.ts' | sed 's/.*export //' | sed 's/[(<:].*//' | sort -u", tags: ["quality"], collection: "quality", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+    { id: "sys-security", name: "security-scan", description: "Scan for common security anti-patterns", command: "grep -rn 'eval\\|exec\\|spawn\\|innerHTML\\|dangerouslySetInnerHTML\\|password.*=.*[\"'\\']' {path} --include='*.ts' --include='*.js' --include='*.py'", tags: ["security"], collection: "quality", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+    // Project info
+    { id: "sys-deps", name: "list-deps", description: "Show project dependencies", command: "cat package.json 2>/dev/null | grep -A 100 '\"dependencies\"' | head -30 || cat requirements.txt 2>/dev/null || cat Cargo.toml 2>/dev/null | grep -A 50 'dependencies'", tags: ["deps"], collection: "project", variables: [], createdAt: 0, updatedAt: 0 },
+    { id: "sys-size", name: "project-size", description: "Count lines of code by file type", command: "find {path} -not -path '*/node_modules/*' -not -path '*/dist/*' -not -path '*/.git/*' -type f | xargs wc -l 2>/dev/null | sort -rn | head -20", tags: ["stats"], collection: "project", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+    // Process management
+    { id: "sys-port", name: "kill-port", description: "Kill whatever is running on a port", command: "lsof -ti :{port} | xargs kill -9 2>/dev/null || echo 'Port {port} is free'", tags: ["process"], collection: "system", variables: [{ name: "port", required: true }], createdAt: 0, updatedAt: 0 },
+    { id: "sys-disk", name: "disk-usage", description: "Show disk usage of current directory", command: "du -sh {path}/* 2>/dev/null | sort -rh | head -15", tags: ["system"], collection: "system", variables: [{ name: "path", default: "." }], createdAt: 0, updatedAt: 0 },
+];
 // ── CRUD operations ──────────────────────────────────────────────────────────
-/** Get all recipes (merged: global + project-scoped) */
+/** Get all recipes (merged: system + global + project-scoped) */
 export function listRecipes(projectPath) {
     const global = loadStore(GLOBAL_FILE).recipes;
     if (!projectPath)
-        return global;
+        return [...global, ...SYSTEM_RECIPES];
     const project = loadStore(projectFile(projectPath)).recipes;
-    return [...project, ...global]; // project recipes first (higher priority)
+    return [...project, ...global, ...SYSTEM_RECIPES]; // project > global > system priority
 }
 /** Get recipes filtered by collection */
 export function listByCollection(collection, projectPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/terminal",
-  "version": "3.5.0",
+  "version": "3.7.0",
   "description": "Smart terminal wrapper for AI agents and humans — structured output, token compression, MCP server, natural language",
   "type": "module",
   "files": [

package/src/mcp/server.ts

@@ -181,7 +181,7 @@ export function createServer(): McpServer {
 
   server.tool(
     "execute_smart",
-    "Run a command and get AI-summarized output. The AI decides what's important — errors, failures, key results are kept; verbose logs, progress bars, passing tests are dropped. Saves 80-95% tokens vs raw output. Best tool for agents.",
+    "Run a command and get AI-summarized output (80-95% token savings). Use this for: test runs, builds, git operations, process management, system info. Do NOT use for file read/write — use your native Read/Write/Edit tools instead (they're faster, no shell overhead).",
     {
       command: z.string().describe("Shell command to execute"),
       cwd: z.string().optional().describe("Working directory"),
@@ -678,7 +678,7 @@ export function createServer(): McpServer {
 
   server.tool(
     "read_file",
-    "Read a file with session caching. Use summarize=true to get an AI-generated outline (~90% fewer tokens) instead of full content — ideal when you just want to understand what a file does without reading every line.",
+    "Read a file with summarize=true for AI outline (~90% fewer tokens). For full file reads without summarization, prefer your native Read tool (faster, no MCP overhead). Use this when you want cached reads or AI summaries.",
     {
       path: z.string().describe("File path"),
       offset: z.number().optional().describe("Start line (0-indexed)"),
@@ -858,6 +858,161 @@ Match by function name, class name, method name (including ClassName.method), in
     }
   );
 
+  // ── Intent-level tools — agents express WHAT, we handle HOW ───────────────
+
+  server.tool(
+    "commit",
+    "Commit and optionally push. Agent says what to commit, we handle git add/commit/push. Saves ~400 tokens vs raw git commands.",
+    {
+      message: z.string().describe("Commit message"),
+      files: z.array(z.string()).optional().describe("Files to stage (default: all changed)"),
+      push: z.boolean().optional().describe("Push after commit (default: false)"),
+      cwd: z.string().optional().describe("Working directory"),
+    },
+    async ({ message, files, push, cwd }) => {
+      const start = Date.now();
+      const workDir = cwd ?? process.cwd();
+      const addCmd = files && files.length > 0 ? `git add ${files.map(f => `"${f}"`).join(" ")}` : "git add -A";
+      const commitCmd = `${addCmd} && git commit -m ${JSON.stringify(message)}`;
+      const fullCmd = push ? `${commitCmd} && git push` : commitCmd;
+
+      const result = await exec(fullCmd, workDir, 30000);
+      const output = (result.stdout + result.stderr).trim();
+      logCall("commit", { command: `commit: ${message.slice(0, 80)}`, durationMs: Date.now() - start, exitCode: result.exitCode });
+      invalidateBootCache();
+
+      return { content: [{ type: "text" as const, text: JSON.stringify({
+        exitCode: result.exitCode,
+        output: stripAnsi(output).split("\n").filter(l => l.trim()).slice(0, 5).join("\n"),
+        pushed: push ?? false,
+      }) }] };
+    }
+  );
+
+  server.tool(
+    "run",
+    "Run a project task by intent — test, build, lint, dev, typecheck, format. Auto-detects toolchain (bun/npm/pnpm/yarn/cargo/go/make). Saves ~100 tokens vs raw commands.",
+    {
+      task: z.enum(["test", "build", "lint", "dev", "start", "typecheck", "format", "check"]).describe("What to run"),
+      args: z.string().optional().describe("Extra arguments (e.g., '--watch', 'src/foo.test.ts')"),
+      cwd: z.string().optional().describe("Working directory"),
+    },
+    async ({ task, args, cwd }) => {
+      const start = Date.now();
+      const workDir = cwd ?? process.cwd();
+
+      // Detect toolchain from project files
+      const { existsSync } = await import("fs");
+      const { join } = await import("path");
+      let runner = "npm run";
+      if (existsSync(join(workDir, "bun.lockb")) || existsSync(join(workDir, "bun.lock"))) runner = "bun run";
+      else if (existsSync(join(workDir, "pnpm-lock.yaml"))) runner = "pnpm run";
+      else if (existsSync(join(workDir, "yarn.lock"))) runner = "yarn";
+      else if (existsSync(join(workDir, "Cargo.toml"))) runner = "cargo";
+      else if (existsSync(join(workDir, "go.mod"))) runner = "go";
+      else if (existsSync(join(workDir, "Makefile"))) runner = "make";
+
+      // Map intent to command
+      let cmd: string;
+      if (runner === "cargo") {
+        cmd = `cargo ${task}${args ? ` ${args}` : ""}`;
+      } else if (runner === "go") {
+        const goMap: Record<string, string> = { test: "go test ./...", build: "go build ./...", lint: "golangci-lint run", format: "gofmt -w .", check: "go vet ./..." };
+        cmd = goMap[task] ?? `go ${task}`;
+      } else if (runner === "make") {
+        cmd = `make ${task}${args ? ` ${args}` : ""}`;
+      } else {
+        // JS/TS ecosystem
+        const jsMap: Record<string, string> = { test: "test", build: "build", lint: "lint", dev: "dev", start: "start", typecheck: "typecheck", format: "format", check: "check" };
+        cmd = `${runner} ${jsMap[task] ?? task}${args ? ` ${args}` : ""}`;
+      }
+
+      const result = await exec(cmd, workDir, 120000);
+      const output = (result.stdout + result.stderr).trim();
+      const processed = await processOutput(cmd, output);
+      logCall("run", { command: `${task}${args ? ` ${args}` : ""}`, outputTokens: estimateTokens(output), tokensSaved: processed.tokensSaved, durationMs: Date.now() - start, exitCode: result.exitCode, aiProcessed: processed.aiProcessed });
+
+      return { content: [{ type: "text" as const, text: JSON.stringify({
+        exitCode: result.exitCode,
+        task,
+        runner,
+        summary: processed.summary,
+        tokensSaved: processed.tokensSaved,
+      }) }] };
+    }
+  );
+
+  server.tool(
+    "edit",
+    "Find and replace in a file. For simple edits, prefer your native Edit tool (faster). Use this for batch replacements (all=true) or when you don't have a native Edit tool available.",
+    {
+      file: z.string().describe("File path"),
+      find: z.string().describe("Text to find (exact match)"),
+      replace: z.string().describe("Replacement text"),
+      all: z.boolean().optional().describe("Replace all occurrences (default: first only)"),
+    },
+    async ({ file, find, replace, all }) => {
+      const start = Date.now();
+      const { readFileSync, writeFileSync } = await import("fs");
+      try {
+        let content = readFileSync(file, "utf8");
+        const count = (content.match(new RegExp(find.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")) || []).length;
+        if (count === 0) {
+          return { content: [{ type: "text" as const, text: JSON.stringify({ error: "Text not found", file }) }] };
+        }
+        if (all) {
+          content = content.split(find).join(replace);
+        } else {
+          content = content.replace(find, replace);
+        }
+        writeFileSync(file, content);
+        logCall("edit", { command: `edit ${file}`, durationMs: Date.now() - start });
+        return { content: [{ type: "text" as const, text: JSON.stringify({ ok: true, file, replacements: all ? count : 1 }) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text" as const, text: JSON.stringify({ error: e.message }) }] };
+      }
+    }
+  );
+
+  server.tool(
+    "lookup",
+    "Search for specific items in a file by name or pattern. Agent says what to find, not how to grep. Saves ~300 tokens vs constructing grep pipelines.",
+    {
+      file: z.string().describe("File path to search in"),
+      items: z.array(z.string()).describe("Names or patterns to look up"),
+      context: z.number().optional().describe("Lines of context around each match (default: 3)"),
+    },
+    async ({ file, items, context }) => {
+      const start = Date.now();
+      const { readFileSync } = await import("fs");
+      try {
+        const content = readFileSync(file, "utf8");
+        const lines = content.split("\n");
+        const ctx = context ?? 3;
+        const results: Record<string, { line: number; text: string; context: string[] }[]> = {};
+
+        for (const item of items) {
+          results[item] = [];
+          const pattern = new RegExp(item.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+          for (let i = 0; i < lines.length; i++) {
+            if (pattern.test(lines[i])) {
+              results[item].push({
+                line: i + 1,
+                text: lines[i].trim(),
+                context: lines.slice(Math.max(0, i - ctx), i + ctx + 1).map(l => l.trimEnd()),
+              });
+            }
+          }
+        }
+
+        logCall("lookup", { command: `lookup ${file} [${items.join(",")}]`, durationMs: Date.now() - start });
+        return { content: [{ type: "text" as const, text: JSON.stringify(results) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text" as const, text: JSON.stringify({ error: e.message }) }] };
+      }
+    }
+  );
+
   return server;
 }
 

package/src/recipes/storage.ts

@@ -28,14 +28,36 @@ function saveStore(filePath: string, store: RecipeStore): void {
   writeFileSync(filePath, JSON.stringify(store, null, 2));
 }
 
+// ── Built-in system recipes (always available, zero config) ─────────────────
+
+const SYSTEM_RECIPES: Recipe[] = [
+  // Git workflows
+  { id: "sys-commit-push", name: "commit-push", description: "Stage all, commit, push to origin", command: "git add -A && git commit -m \"{message}\" && git push", tags: ["git"], collection: "git", variables: [{ name: "message", required: true }], createdAt: 0, updatedAt: 0 },
+  { id: "sys-pr", name: "create-pr", description: "Create GitHub PR from current branch", command: "gh pr create --title \"{title}\" --body \"{body}\"", tags: ["git", "github"], collection: "git", variables: [{ name: "title", required: true }, { name: "body", default: "" }], createdAt: 0, updatedAt: 0 },
+  { id: "sys-stash", name: "stash-switch", description: "Stash changes, switch branch, pop", command: "git stash && git checkout {branch} && git stash pop", tags: ["git"], collection: "git", variables: [{ name: "branch", required: true }], createdAt: 0, updatedAt: 0 },
+
+  // Quality checks
+  { id: "sys-todos", name: "find-todos", description: "Find all TODO/FIXME/HACK in source code", command: "grep -rn 'TODO\\|FIXME\\|HACK\\|XXX' {path} --include='*.ts' --include='*.tsx' --include='*.js' --include='*.py' --include='*.go' --include='*.rs' --include='*.java' --include='*.rb'", tags: ["quality"], collection: "quality", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+  { id: "sys-deadcode", name: "find-unused-exports", description: "Find exported symbols that may be unused", command: "grep -rn 'export ' {path} --include='*.ts' | sed 's/.*export //' | sed 's/[(<:].*//' | sort -u", tags: ["quality"], collection: "quality", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+  { id: "sys-security", name: "security-scan", description: "Scan for common security anti-patterns", command: "grep -rn 'eval\\|exec\\|spawn\\|innerHTML\\|dangerouslySetInnerHTML\\|password.*=.*[\"'\\']' {path} --include='*.ts' --include='*.js' --include='*.py'", tags: ["security"], collection: "quality", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+
+  // Project info
+  { id: "sys-deps", name: "list-deps", description: "Show project dependencies", command: "cat package.json 2>/dev/null | grep -A 100 '\"dependencies\"' | head -30 || cat requirements.txt 2>/dev/null || cat Cargo.toml 2>/dev/null | grep -A 50 'dependencies'", tags: ["deps"], collection: "project", variables: [], createdAt: 0, updatedAt: 0 },
+  { id: "sys-size", name: "project-size", description: "Count lines of code by file type", command: "find {path} -not -path '*/node_modules/*' -not -path '*/dist/*' -not -path '*/.git/*' -type f | xargs wc -l 2>/dev/null | sort -rn | head -20", tags: ["stats"], collection: "project", variables: [{ name: "path", default: "src/" }], createdAt: 0, updatedAt: 0 },
+
+  // Process management
+  { id: "sys-port", name: "kill-port", description: "Kill whatever is running on a port", command: "lsof -ti :{port} | xargs kill -9 2>/dev/null || echo 'Port {port} is free'", tags: ["process"], collection: "system", variables: [{ name: "port", required: true }], createdAt: 0, updatedAt: 0 },
+  { id: "sys-disk", name: "disk-usage", description: "Show disk usage of current directory", command: "du -sh {path}/* 2>/dev/null | sort -rh | head -15", tags: ["system"], collection: "system", variables: [{ name: "path", default: "." }], createdAt: 0, updatedAt: 0 },
+];
+
 // ── CRUD operations ──────────────────────────────────────────────────────────
 
-/** Get all recipes (merged: global + project-scoped) */
+/** Get all recipes (merged: system + global + project-scoped) */
 export function listRecipes(projectPath?: string): Recipe[] {
   const global = loadStore(GLOBAL_FILE).recipes;
-  if (!projectPath) return global;
+  if (!projectPath) return [...global, ...SYSTEM_RECIPES];
   const project = loadStore(projectFile(projectPath)).recipes;
-  return [...project, ...global]; // project recipes first (higher priority)
+  return [...project, ...global, ...SYSTEM_RECIPES]; // project > global > system priority
 }
 
 /** Get recipes filtered by collection */