second-advisor 0.1.0

package/src/config.ts

@@ -0,0 +1,118 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import {
+  ampModes,
+  ampThinking,
+  type Config,
+  claudeModels,
+  claudeThinking,
+  codexThinking,
+  getThinkingOptions,
+  isAdvisor,
+  piThinking,
+} from "./advisors.js";
+
+export const configPath = path.join(
+  homedir(),
+  ".config",
+  "second-advisor",
+  "config.json",
+);
+
+export function parseConfig(value: unknown): Config {
+  if (!isRecord(value)) throw new Error("Config must be an object");
+  if (!isAdvisor(value.advisor)) throw new Error("Invalid advisor");
+  if (typeof value.model !== "string" || value.model.length === 0) {
+    throw new Error("Config model must be a non-empty string");
+  }
+
+  if (value.advisor === "kimi") {
+    if ("thinking" in value) throw new Error("Kimi does not support thinking");
+    return { advisor: value.advisor, model: value.model };
+  }
+
+  if (typeof value.thinking !== "string" || value.thinking.length === 0) {
+    throw new Error("Config thinking must be a non-empty string");
+  }
+
+  if (value.advisor === "amp") {
+    if (!ampModes.includes(value.model as (typeof ampModes)[number])) {
+      throw new Error("Invalid Amp mode");
+    }
+    if (!ampThinking.includes(value.thinking as (typeof ampThinking)[number])) {
+      throw new Error("Invalid Amp thinking");
+    }
+    if (!getThinkingOptions("amp", value.model).includes(value.thinking)) {
+      throw new Error("Invalid Amp thinking");
+    }
+    return {
+      advisor: value.advisor,
+      model: value.model as (typeof ampModes)[number],
+      thinking: value.thinking as (typeof ampThinking)[number],
+    };
+  }
+
+  if (value.advisor === "claude") {
+    if (!claudeModels.includes(value.model as (typeof claudeModels)[number])) {
+      throw new Error("Invalid Claude model");
+    }
+    if (
+      !claudeThinking.includes(
+        value.thinking as (typeof claudeThinking)[number],
+      )
+    ) {
+      throw new Error("Invalid Claude thinking");
+    }
+    return {
+      advisor: value.advisor,
+      model: value.model as (typeof claudeModels)[number],
+      thinking: value.thinking as (typeof claudeThinking)[number],
+    };
+  }
+
+  if (value.advisor === "codex") {
+    if (
+      !codexThinking.includes(value.thinking as (typeof codexThinking)[number])
+    ) {
+      throw new Error("Invalid Codex thinking");
+    }
+    return {
+      advisor: value.advisor,
+      model: value.model,
+      thinking: value.thinking as (typeof codexThinking)[number],
+    };
+  }
+
+  if (value.advisor === "pi") {
+    if (!piThinking.includes(value.thinking as (typeof piThinking)[number])) {
+      throw new Error("Invalid Pi thinking");
+    }
+    return {
+      advisor: value.advisor,
+      model: value.model,
+      thinking: value.thinking as (typeof piThinking)[number],
+    };
+  }
+
+  return {
+    advisor: value.advisor,
+    model: value.model,
+    thinking: value.thinking,
+  };
+}
+
+export async function readConfigIfPresent() {
+  if (!existsSync(configPath)) return undefined;
+  return parseConfig(JSON.parse(await readFile(configPath, "utf8")));
+}
+
+export async function writeConfig(config: Config) {
+  await mkdir(path.dirname(configPath), { recursive: true });
+  await writeFile(configPath, `${JSON.stringify(config, undefined, 2)}\n`);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/index.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env bun
+import { Command } from "commander";
+import { parseCliRequest } from "./routing.js";
+import {
+  runDoctor,
+  runInit,
+  runMenu,
+  runModels,
+  runPrompt,
+  runSetup,
+  runStatus,
+} from "./ui.js";
+
+export {
+  advisorChoices,
+  buildAdvisorCommand,
+  getModelListCommand,
+  summarizeConfig,
+} from "./advisors.js";
+export { parseConfig } from "./config.js";
+export { parseCliRequest } from "./routing.js";
+
+async function main() {
+  const program = new Command()
+    .name("second-advisor")
+    .description("Consult a configured coding CLI for a second opinion.")
+    .argument("[input...]", "prompt to send to the configured advisor")
+    .option("--debug", "print the coding CLI command before running it")
+    .allowUnknownOption(false)
+    .helpOption("-h, --help", "display help")
+    .addHelpText(
+      "after",
+      `
+Examples:
+  second-advisor
+  second-advisor init
+  second-advisor doctor
+  second-advisor models
+  second-advisor setup
+  second-advisor "what do you think about this implementation?"
+`,
+    );
+
+  program.parse(process.argv);
+  const request = parseCliRequest(program.args);
+  const options = program.opts<{ debug?: boolean }>();
+
+  if (request.kind === "menu") {
+    await runMenu();
+    return;
+  }
+
+  if (request.kind === "prompt") {
+    await runPrompt(request.prompt, { debug: options.debug === true });
+    return;
+  }
+
+  if (request.command === "init") {
+    await runInit();
+    return;
+  }
+
+  if (request.command === "doctor") {
+    await runDoctor();
+    return;
+  }
+
+  if (request.command === "models") {
+    await runModels(request.args[0]);
+    return;
+  }
+
+  if (request.command === "setup") {
+    await runSetup();
+    return;
+  }
+
+  await runStatus();
+}
+
+if (import.meta.main) {
+  main().catch((error: unknown) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}

package/src/models.ts

@@ -0,0 +1,87 @@
+import {
+  type Advisor,
+  ampModes,
+  claudeModels,
+  getModelListCommand,
+} from "./advisors.js";
+import { runCommand } from "./process.js";
+
+export async function loadModelChoices(advisor: Advisor) {
+  if (advisor === "amp") return [...ampModes];
+  if (advisor === "claude") return [...claudeModels];
+  const command = getModelListCommand(advisor);
+  if (!command) return [];
+
+  const result = await runCommand(command.command, command.args, {
+    pipeOutput: true,
+  });
+  if (result.exitCode !== 0) return [];
+  return parseModelChoices(advisor, result.stdout).slice(0, 80);
+}
+
+export function parseModelChoices(advisor: Advisor, output: string) {
+  if (advisor === "codex") return extractCodexModels(output);
+  if (advisor === "grok") return extractGrokModels(output);
+  if (advisor === "kimi") return extractKimiModels(output);
+  if (advisor === "droid") return extractDroidModels(output);
+  return output
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0 && !line.startsWith("Warning:"))
+    .map((line) => line.replace(/^[-*]\s*/, ""))
+    .filter((line) => line.length > 0);
+}
+
+function extractKimiModels(output: string) {
+  try {
+    const json = JSON.parse(output);
+    if (!isRecord(json) || !isRecord(json.models)) return [];
+    return Object.keys(json.models).filter((model) => model.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+function extractGrokModels(output: string) {
+  const models = output.match(/Available models:\n(?<body>[\s\S]*)/)?.groups
+    ?.body;
+  if (!models) return [];
+  return models
+    .split(/\r?\n/)
+    .map((line) =>
+      line
+        .trim()
+        .replace(/^[-*]\s*/, "")
+        .replace(/\s+\(default\)$/, ""),
+    )
+    .filter((value) => value.length > 0);
+}
+
+function extractCodexModels(output: string) {
+  try {
+    const json = JSON.parse(output);
+    if (!isRecord(json) || !Array.isArray(json.models)) return [];
+    return json.models
+      .map((model) => (isRecord(model) ? model.slug : undefined))
+      .filter(
+        (slug): slug is string => typeof slug === "string" && slug.length > 0,
+      );
+  } catch {
+    return [];
+  }
+}
+
+function extractDroidModels(output: string) {
+  const models = output.match(
+    /Available Models:\n(?<body>[\s\S]*?)\n\nModel details:/,
+  )?.groups?.body;
+  if (!models) return [];
+  return models
+    .split(/\r?\n/)
+    .map((line) => line.trim().split(/\s+/)[0])
+    .filter((value) => value.length > 0);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/process.ts

@@ -0,0 +1,47 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+export function resolveExecutable(command: string) {
+  const pathValue = process.env.PATH || "";
+  return pathValue
+    .split(path.delimiter)
+    .map((directory) => path.join(directory, command))
+    .find((candidate) => existsSync(candidate));
+}
+
+export function getVersionArgs() {
+  return ["--version"];
+}
+
+export function runCommand(
+  command: string,
+  args: string[],
+  options: { pipeOutput: boolean },
+) {
+  return new Promise<{ exitCode: number; stdout: string; stderr: string }>(
+    (resolve) => {
+      const child = spawn(command, args, {
+        stdio: options.pipeOutput ? ["ignore", "pipe", "pipe"] : "inherit",
+      });
+      const stdout: Buffer[] = [];
+      const stderr: Buffer[] = [];
+
+      if (options.pipeOutput) {
+        child.stdout?.on("data", (chunk: Buffer) => stdout.push(chunk));
+        child.stderr?.on("data", (chunk: Buffer) => stderr.push(chunk));
+      }
+
+      child.on("error", (error) =>
+        resolve({ exitCode: 1, stdout: "", stderr: error.message }),
+      );
+      child.on("close", (code) =>
+        resolve({
+          exitCode: code || 0,
+          stdout: Buffer.concat(stdout).toString("utf8"),
+          stderr: Buffer.concat(stderr).toString("utf8"),
+        }),
+      );
+    },
+  );
+}

package/src/routing.ts

@@ -0,0 +1,19 @@
+const commands = ["init", "doctor", "models", "setup", "status"] as const;
+
+type CommandName = (typeof commands)[number];
+
+export type CliRequest =
+  | { kind: "menu" }
+  | { kind: "prompt"; prompt: string }
+  | { kind: "command"; command: CommandName; args: string[] };
+
+export function parseCliRequest(args: string[]): CliRequest {
+  if (args.length === 0) return { kind: "menu" };
+  if (isCommandName(args[0]))
+    return { kind: "command", command: args[0], args: args.slice(1) };
+  return { kind: "prompt", prompt: args.join(" ") };
+}
+
+function isCommandName(value: string): value is CommandName {
+  return commands.includes(value as CommandName);
+}