overseer-mcp 0.1.1 → 0.2.0

package/dist/index.js

@@ -10,7 +10,7 @@ import { consultExpertInputSchema, handleConsultExpert } from "./tools/consultEx
 import { getPlanInputSchema, handleGetPlan } from "./tools/getPlan.js";
 import { handleRequestReview, requestReviewInputSchema } from "./tools/requestReview.js";
 export function createServer(config) {
-    const server = new McpServer({ name: "overseer-mcp", version: "0.1.1" });
+    const server = new McpServer({ name: "overseer-mcp", version: "0.2.0" });
     server.registerTool("get_plan", {
         title: "Get implementation plan",
         description: "Call before writing any code. Forward the user's request so the expert can produce a surgical plan from real git and disk context.",

package/dist/init/command.js

@@ -34,16 +34,35 @@ async function interactiveArgs(io, scriptPath) {
             "",
         ].join("\n"));
         const expert = parseExpertAnswer(await ask(rl, "Choose expert", "1"));
-        const args = ["--print", "--expert", expert, "--name", await ask(rl, "MCP server name", "overseer")];
+        const targetAnswer = await ask(rl, "Output format: 1=json (most agents) or 2=codex (TOML)", "1");
+        const target = targetAnswer === "2" || targetAnswer === "codex" ? "codex" : "json";
+        const args = ["--print", "--expert", expert, "--target", target, "--name", await ask(rl, "MCP server name", "overseer")];
         args.push("--repo-root", await ask(rl, "Repo root", process.cwd()));
         const testCommand = await ask(rl, "Validation command, empty to skip");
         if (testCommand)
             args.push("--test-command", testCommand);
         if (expert === "cli") {
-            args.push("--cli-command", await ask(rl, "CLI command", "codex"));
-            const cliArgs = await ask(rl, "CLI args as JSON array", '["exec"]');
-            if (cliArgs)
-                args.push("--cli-args", cliArgs);
+            const cliCommand = await ask(rl, "CLI command", "codex");
+            args.push("--cli-command", cliCommand);
+            write(io.stdout, [
+                "",
+                "CLI expert configuration:",
+                "  The expert will be invoked as: <command> <args...> <prompt-via-stdin-or-arg>",
+                "  Include any flags like --model, --reasoning-effort, etc. in the args.",
+                "",
+                "  Examples:",
+                '    codex: exec --model o3 --reasoning-effort high',
+                '    claude: -p  (with --cli-prompt-via arg)',
+                "",
+            ].join("\n"));
+            const rawArgs = await ask(rl, "CLI args (space-separated)", cliCommand === "codex" ? "exec --model o3 --reasoning-effort high" : "exec");
+            if (rawArgs)
+                args.push("--cli-args", rawArgs);
+            if (cliCommand === "claude") {
+                const promptVia = await ask(rl, "How does the prompt reach the CLI? stdin or arg", "arg");
+                if (promptVia === "arg")
+                    args.push("--cli-prompt-via", "arg");
+            }
             const login = await ask(rl, "Run CLI login now? yes/no", "no");
             if (login.toLowerCase().startsWith("y"))
                 args.push("--run-login");
@@ -91,7 +110,37 @@ async function runLogin(parsed, io) {
     });
 }
 export async function runInit(argv, io = process, scriptPath) {
-    const parsed = argv.length > 0 ? parseInitArgs(argv, scriptPath) : await interactiveArgs(io, scriptPath);
+    if (argv.length > 0) {
+        const parsed = parseInitArgs(argv, scriptPath);
+        await runLogin(parsed, io);
+        const text = parsed.target === "json" ? buildGenericMcpJson([parsed.profile]) : `${buildCodexToml([parsed.profile])}\n`;
+        write(io.stdout, text);
+        return;
+    }
+    // Interactive mode: check if stdin can actually handle interactive input
+    const stdin = io.stdin;
+    if (!stdin.isTTY) {
+        write(io.stderr, [
+            "overseer-mcp init: interactive mode requires a terminal (TTY).",
+            "",
+            "Use flags instead. Add --use-npx to generate portable configs.",
+            "",
+            "  # CLI expert — Codex with o3 + high reasoning:",
+            '  npx -y overseer-mcp init --expert cli --cli-command codex --cli-args "exec --model o3 --reasoning-effort high" --target json --print',
+            "",
+            "  # OpenAI expert (GPT-4o):",
+            '  npx -y overseer-mcp init --expert openai --model gpt-4o --api-key-env OPENAI_API_KEY --target json --print',
+            "",
+            "  # Anthropic expert (Claude):",
+            '  npx -y overseer-mcp init --expert anthropic --model claude-sonnet-4-20250514 --api-key-env ANTHROPIC_API_KEY --target json --print',
+            "",
+            "  # CLI expert — Claude Code:",
+            '  npx -y overseer-mcp init --expert cli --cli-command claude --cli-args "-p" --cli-prompt-via arg --target json --print',
+            "",
+        ].join("\n") + "\n");
+        return;
+    }
+    const parsed = await interactiveArgs(io, scriptPath);
     await runLogin(parsed, io);
     const text = parsed.target === "json" ? buildGenericMcpJson([parsed.profile]) : `${buildCodexToml([parsed.profile])}\n`;
     write(io.stdout, text);

package/dist/init/config.js

@@ -145,6 +145,12 @@ export function buildGenericMcpJson(profiles) {
     return `${JSON.stringify({ mcpServers }, null, 2)}\n`;
 }
 export function defaultServerCommand(scriptPath = process.argv[1] ?? "dist/index.js") {
+    // When installed via npm/npx, prefer `npx -y overseer-mcp` so the config
+    // is portable and doesn't hard-code a cache path.
+    const isNpx = scriptPath.includes("_npx") || scriptPath.includes("node_modules") || scriptPath.includes(".npm");
+    if (isNpx) {
+        return { command: "npx", args: ["-y", "overseer-mcp"] };
+    }
     return {
         command: "node",
         args: [configPath(path.resolve(scriptPath))],
@@ -160,12 +166,16 @@ export function parseInitArgs(argv, scriptPath) {
     const flags = readFlagMap(argv);
     const target = parseTarget(getOne(flags, "target"));
     const expert = parseExpert(getOne(flags, "expert"));
+    const useNpx = flags.has("use-npx");
+    const defaultCmd = useNpx
+        ? { command: "npx", args: ["-y", "overseer-mcp"] }
+        : defaultServerCommand(scriptPath);
     const server = {
-        command: getOne(flags, "server-command") ?? defaultServerCommand(scriptPath).command,
+        command: getOne(flags, "server-command") ?? defaultCmd.command,
         args: getMany(flags, "server-arg"),
     };
     if (server.args.length === 0) {
-        server.args = defaultServerCommand(scriptPath).args;
+        server.args = defaultCmd.args;
     }
     const repoRoot = getOne(flags, "repo-root") ?? process.cwd();
     const cliArgs = parseList(getOne(flags, "cli-args"));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "overseer-mcp",
-  "version": "0.1.1",
-  "description": "An MCP server that lets a cheaper executor agent consult a more capable expert model at the three moments it tends to derail: planning, mid-implementation decisions, and final review. The expert reads ground truth (git + disk), never the executor's summary.",
+  "version": "0.2.0",
+  "description": "MCP server that lets a cheap executor agent consult a capable expert at three gates: planning, mid-implementation decisions, and final review. Expert receives executor summaries and real evidence, never reads the repo directly.",
   "type": "module",
   "bin": {
     "overseer-mcp": "dist/index.js"