@lenadweb/aicmt 0.1.1

package/dist/cli.js

@@ -0,0 +1,876 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  run: () => run
+});
+module.exports = __toCommonJS(cli_exports);
+var import_commander = require("commander");
+
+// src/commands/commit.ts
+var import_prompts = __toESM(require("prompts"));
+
+// src/config.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_node_os = __toESM(require("os"));
+var import_node_path = __toESM(require("path"));
+var import_zod = require("zod");
+
+// src/constants.ts
+var CONFIG_DIR_NAME = "aicmt";
+var CONFIG_FILENAME = "config.json";
+var DEFAULT_MODEL = "openai/gpt-4o-mini";
+var DEFAULT_TEMPERATURE = 0.2;
+var DEFAULT_MAX_TOKENS = 120;
+var MIN_OUTPUT_TOKENS = 32;
+var MAX_OUTPUT_TOKENS = 512;
+
+// src/config.ts
+var sharedConfigSchema = import_zod.z.object({
+  openrouterApiKey: import_zod.z.string().min(1).optional(),
+  model: import_zod.z.string().min(1).optional(),
+  format: import_zod.z.string().min(1).optional(),
+  instructions: import_zod.z.string().min(1).optional(),
+  temperature: import_zod.z.number().min(0).max(2).optional(),
+  maxTokens: import_zod.z.number().int().positive().optional()
+}).strict();
+var projectConfigSchema = sharedConfigSchema;
+var globalConfigSchema = sharedConfigSchema.extend({
+  projects: import_zod.z.record(projectConfigSchema).default({})
+}).strict();
+function getDefaultConfigPath() {
+  var _a;
+  const base = (_a = process.env.XDG_CONFIG_HOME) == null ? void 0 : _a.trim();
+  const configDir = base ? import_node_path.default.join(base, CONFIG_DIR_NAME) : import_node_path.default.join(import_node_os.default.homedir(), ".config", CONFIG_DIR_NAME);
+  return import_node_path.default.join(configDir, CONFIG_FILENAME);
+}
+function resolveConfigPath(repoRoot, providedPath) {
+  if (providedPath) {
+    return import_node_path.default.isAbsolute(providedPath) ? providedPath : import_node_path.default.resolve(repoRoot, providedPath);
+  }
+  return getDefaultConfigPath();
+}
+function clampMaxTokens(value) {
+  if (value < MIN_OUTPUT_TOKENS) {
+    return MIN_OUTPUT_TOKENS;
+  }
+  if (value > MAX_OUTPUT_TOKENS) {
+    return MAX_OUTPUT_TOKENS;
+  }
+  return value;
+}
+function applyDefaults(config) {
+  return {
+    openrouterApiKey: config.openrouterApiKey,
+    model: config.model,
+    format: config.format,
+    instructions: config.instructions,
+    temperature: typeof config.temperature === "number" ? config.temperature : DEFAULT_TEMPERATURE,
+    maxTokens: typeof config.maxTokens === "number" ? clampMaxTokens(config.maxTokens) : DEFAULT_MAX_TOKENS
+  };
+}
+function resolveProjectConfig(globalConfig, repoRoot) {
+  const { projects = {}, ...defaults } = globalConfig;
+  const projectConfig = projects[repoRoot] ?? {};
+  const merged = { ...defaults, ...projectConfig };
+  const missing = [];
+  if (!merged.openrouterApiKey) {
+    missing.push("openrouterApiKey");
+  }
+  if (!merged.model) {
+    missing.push("model");
+  }
+  if (!merged.format) {
+    missing.push("format");
+  }
+  if (!merged.instructions) {
+    missing.push("instructions");
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing ${missing.join(", ")} in config. Run aicmt init to set defaults.`
+    );
+  }
+  return applyDefaults({
+    openrouterApiKey: merged.openrouterApiKey,
+    model: merged.model,
+    format: merged.format,
+    instructions: merged.instructions,
+    temperature: merged.temperature,
+    maxTokens: merged.maxTokens
+  });
+}
+async function loadGlobalConfig(configPath, options = {}) {
+  let raw;
+  try {
+    raw = await import_promises.default.readFile(configPath, "utf8");
+  } catch (error) {
+    if (options.allowMissing) {
+      return globalConfigSchema.parse({});
+    }
+    throw new Error(`Global config not found at ${configPath}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Invalid JSON in config: ${configPath}`);
+  }
+  const result = globalConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const message = result.error.issues.map((issue) => issue.message).join("; ");
+    throw new Error(`Invalid config: ${message}`);
+  }
+  return result.data;
+}
+async function saveGlobalConfig(configPath, config) {
+  const result = globalConfigSchema.safeParse(config);
+  if (!result.success) {
+    const message = result.error.issues.map((issue) => issue.message).join("; ");
+    throw new Error(`Refusing to write invalid config: ${message}`);
+  }
+  await import_promises.default.mkdir(import_node_path.default.dirname(configPath), { recursive: true });
+  const json = `${JSON.stringify(result.data, null, 2)}
+`;
+  await import_promises.default.writeFile(configPath, json, "utf8");
+}
+
+// src/git.ts
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_os2 = __toESM(require("os"));
+var import_node_path2 = __toESM(require("path"));
+
+// src/utils.ts
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+async function runCommand(command, args, options = {}) {
+  const result = await execFileAsync(command, args, {
+    ...options,
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024
+  });
+  const stdout = typeof result.stdout === "string" ? result.stdout : "";
+  const stderr = typeof result.stderr === "string" ? result.stderr : "";
+  return {
+    stdout: stdout.trimEnd(),
+    stderr: stderr.trimEnd()
+  };
+}
+
+// src/git.ts
+async function runGit(args, cwd) {
+  try {
+    return await runCommand("git", args, { cwd });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Git command failed";
+    const stderr = (error == null ? void 0 : error.stderr) ?? "";
+    const detail = stderr.trim() || message;
+    throw new Error(detail);
+  }
+}
+async function getRepoRoot(cwd) {
+  const result = await runGit(["rev-parse", "--show-toplevel"], cwd);
+  return result.stdout.trim();
+}
+async function isGitRepo(cwd) {
+  try {
+    const result = await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+    return result.stdout.trim() === "true";
+  } catch (error) {
+    return false;
+  }
+}
+function extractPath(rawPath) {
+  const trimmed = rawPath.trim();
+  const arrowIndex = trimmed.indexOf("->");
+  if (arrowIndex === -1) {
+    return trimmed;
+  }
+  return trimmed.slice(arrowIndex + 2).trim();
+}
+function parseStatus(output) {
+  const staged = /* @__PURE__ */ new Set();
+  const unstaged = /* @__PURE__ */ new Set();
+  output.split("\n").map((line) => line.trimEnd()).filter(Boolean).forEach((line) => {
+    if (line.startsWith("??")) {
+      const filePath2 = extractPath(line.slice(2));
+      unstaged.add(filePath2);
+      return;
+    }
+    const indexStatus = line[0];
+    const worktreeStatus = line[1];
+    const filePath = extractPath(line.slice(2));
+    if (indexStatus && indexStatus !== " ") {
+      staged.add(filePath);
+    }
+    if (worktreeStatus && worktreeStatus !== " ") {
+      unstaged.add(filePath);
+    }
+  });
+  return {
+    staged: Array.from(staged),
+    unstaged: Array.from(unstaged)
+  };
+}
+async function getStatus(repoRoot) {
+  const result = await runGit(["status", "--porcelain=v1"], repoRoot);
+  return parseStatus(result.stdout);
+}
+async function stageAll(repoRoot) {
+  await runGit(["add", "-A"], repoRoot);
+}
+async function getStagedDiff(repoRoot) {
+  const result = await runGit(["diff", "--cached"], repoRoot);
+  return result.stdout;
+}
+async function commitWithMessage(repoRoot, message) {
+  if (!message.includes("\n")) {
+    await runGit(["commit", "-m", message], repoRoot);
+    return;
+  }
+  const tempDir = await import_promises2.default.mkdtemp(import_node_path2.default.join(import_node_os2.default.tmpdir(), "aicmt-"));
+  const tempPath = import_node_path2.default.join(tempDir, "commit-message.txt");
+  await import_promises2.default.writeFile(tempPath, message, "utf8");
+  try {
+    await runGit(["commit", "-F", tempPath], repoRoot);
+  } finally {
+    try {
+      await import_promises2.default.unlink(tempPath);
+    } catch (error) {
+    }
+  }
+}
+
+// src/openrouter.ts
+var import_undici = require("undici");
+var LARGE_NEW_FILE_LINE_LIMIT = 400;
+var LARGE_NEW_FILE_HEAD_LINES = 120;
+var LARGE_NEW_FILE_TAIL_LINES = 60;
+function stripCodeFences(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("```")) {
+    return trimmed;
+  }
+  return trimmed.replace(/^```[a-zA-Z]*\n?/, "").replace(/```$/, "").trim();
+}
+function parseJsonArray(text) {
+  const cleaned = stripCodeFences(text);
+  try {
+    const parsed = JSON.parse(cleaned);
+    if (!Array.isArray(parsed)) {
+      return null;
+    }
+    const strings = parsed.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
+    return strings.length ? strings : null;
+  } catch (error) {
+    return null;
+  }
+}
+function parseLines(text) {
+  return text.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => line.replace(/^[-*\d.\)\s]+/, "").trim()).filter(Boolean);
+}
+function splitDiffBlocks(diff) {
+  const lines = diff.split("\n");
+  const blocks = [];
+  let current = [];
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      if (current.length > 0) {
+        blocks.push(current);
+      }
+      current = [line];
+      continue;
+    }
+    current.push(line);
+  }
+  if (current.length > 0) {
+    blocks.push(current);
+  }
+  return blocks;
+}
+function isNewFileBlock(block) {
+  return block.some((line) => line.startsWith("new file mode")) || block.some((line) => line.startsWith("index 0000000.."));
+}
+function compressLargeNewFiles(diff) {
+  if (!diff.trim()) {
+    return diff;
+  }
+  const blocks = splitDiffBlocks(diff);
+  const compressed = blocks.map((block) => {
+    if (!isNewFileBlock(block)) {
+      return block;
+    }
+    const hunkStart = block.findIndex((line) => line.startsWith("@@"));
+    if (hunkStart === -1) {
+      return block;
+    }
+    const header = block.slice(0, hunkStart + 1);
+    const content = block.slice(hunkStart + 1);
+    const addedLineCount = content.filter(
+      (line) => line.startsWith("+") && !line.startsWith("+++")
+    ).length;
+    if (addedLineCount <= LARGE_NEW_FILE_LINE_LIMIT) {
+      return block;
+    }
+    const head = content.slice(0, LARGE_NEW_FILE_HEAD_LINES);
+    const tail = content.slice(-LARGE_NEW_FILE_TAIL_LINES);
+    if (head.length + tail.length >= content.length) {
+      return block;
+    }
+    const omitted = content.length - head.length - tail.length;
+    const marker = `+... [truncated ${omitted} lines from large new file] ...`;
+    return [...header, ...head, marker, ...tail];
+  });
+  return compressed.flat().join("\n");
+}
+function normalizeMessages(messages) {
+  const unique = [];
+  for (const message of messages) {
+    if (!unique.includes(message)) {
+      unique.push(message);
+    }
+  }
+  if (unique.length < 3) {
+    throw new Error("OpenRouter returned fewer than 3 messages");
+  }
+  return unique.slice(0, 3);
+}
+async function generateCommitMessages({
+  apiKey,
+  model,
+  instructions,
+  diff,
+  temperature,
+  maxTokens,
+  onDebug
+}) {
+  var _a, _b, _c;
+  const trimmedDiff = diff.trim();
+  const diffText = trimmedDiff ? compressLargeNewFiles(trimmedDiff) : "[No diff available]";
+  const systemContent = [
+    "You generate git commit messages for staged changes.",
+    "Return ONLY a JSON array of exactly 3 strings.",
+    "Each string must be a commit message that matches the instructions.",
+    "Each option must summarize the full set of changes in this diff as a single commit.",
+    "Do not include any extra commentary or markdown.",
+    "",
+    "Instructions:",
+    instructions
+  ].join("\n");
+  const prompt = diffText;
+  const payload = {
+    model,
+    messages: [
+      {
+        role: "system",
+        content: systemContent
+      },
+      { role: "user", content: prompt }
+    ]
+  };
+  if (typeof temperature === "number") {
+    payload.temperature = temperature;
+  }
+  if (typeof maxTokens === "number") {
+    payload.max_tokens = maxTokens;
+  }
+  onDebug == null ? void 0 : onDebug({ stage: "request", prompt, payload });
+  const response = await (0, import_undici.fetch)("https://openrouter.ai/api/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "HTTP-Referer": "https://aicmt.local",
+      "X-Title": "aicmt"
+    },
+    body: JSON.stringify(payload)
+  });
+  const responseText = await response.text();
+  onDebug == null ? void 0 : onDebug({
+    stage: "response",
+    prompt,
+    payload,
+    responseText,
+    status: response.status
+  });
+  if (!response.ok) {
+    throw new Error(`OpenRouter error: ${response.status} ${responseText}`);
+  }
+  let data;
+  try {
+    data = JSON.parse(responseText);
+  } catch (error) {
+    throw new Error("OpenRouter returned invalid JSON");
+  }
+  const content = ((_c = (_b = (_a = data.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.message) == null ? void 0 : _c.content) ?? "";
+  if (!content) {
+    throw new Error("OpenRouter returned empty content");
+  }
+  const jsonMessages = parseJsonArray(content);
+  if (jsonMessages) {
+    return normalizeMessages(jsonMessages);
+  }
+  const lineMessages = parseLines(content);
+  return normalizeMessages(lineMessages);
+}
+
+// src/commands/commit.ts
+var promptOptions = {
+  onCancel: () => {
+    throw new Error("Cancelled");
+  }
+};
+async function runCommit({
+  cwd,
+  configPath,
+  dryRun = false,
+  verbose = false,
+  yes = false
+}) {
+  const isRepo = await isGitRepo(cwd);
+  if (!isRepo) {
+    throw new Error("Not a git repository. Run inside a git project.");
+  }
+  const repoRoot = await getRepoRoot(cwd);
+  const resolvedConfigPath = resolveConfigPath(repoRoot, configPath);
+  const globalConfig = await loadGlobalConfig(resolvedConfigPath);
+  const config = resolveProjectConfig(globalConfig, repoRoot);
+  let status = await getStatus(repoRoot);
+  if (status.staged.length === 0 && status.unstaged.length === 0) {
+    throw new Error("No changes to commit.");
+  }
+  if (status.unstaged.length > 0) {
+    if (yes) {
+      await stageAll(repoRoot);
+    } else {
+      const { stage } = await (0, import_prompts.default)(
+        {
+          type: "confirm",
+          name: "stage",
+          message: "Unstaged changes detected. Stage all changes?",
+          initial: true
+        },
+        promptOptions
+      );
+      if (!stage) {
+        throw new Error("Aborted: commit requires all changes to be staged.");
+      }
+      await stageAll(repoRoot);
+    }
+    status = await getStatus(repoRoot);
+  }
+  if (status.staged.length === 0) {
+    throw new Error("No staged changes to commit.");
+  }
+  const diff = await getStagedDiff(repoRoot);
+  const debugInfo = {};
+  const messages = await generateCommitMessages({
+    apiKey: config.openrouterApiKey,
+    model: config.model,
+    instructions: config.instructions,
+    diff,
+    temperature: config.temperature,
+    maxTokens: config.maxTokens,
+    onDebug: (info) => {
+      if (info.stage === "request") {
+        debugInfo.request = info;
+      } else {
+        debugInfo.response = info;
+      }
+    }
+  });
+  if (verbose) {
+    if (debugInfo.request) {
+      console.log("[aicmt] AI request payload:");
+      console.log(JSON.stringify(debugInfo.request.payload, null, 2));
+      console.log("[aicmt] AI request prompt:");
+      console.log(debugInfo.request.prompt);
+    }
+    if (debugInfo.response) {
+      const status2 = debugInfo.response.status ?? "unknown";
+      console.log(`[aicmt] AI response (status ${status2}):`);
+      console.log(debugInfo.response.responseText ?? "");
+    }
+  }
+  let finalMessage = messages[0] ?? "";
+  if (!yes) {
+    const choicePrompt = await (0, import_prompts.default)(
+      {
+        type: "select",
+        name: "selection",
+        message: "Choose a commit message",
+        choices: [
+          ...messages.map((message, index) => ({
+            title: message,
+            value: message,
+            description: `Option ${index + 1}`
+          })),
+          { title: "Custom message", value: "__custom", description: "Write your own" },
+          { title: "Abort", value: "__abort", description: "Cancel commit" }
+        ]
+      },
+      promptOptions
+    );
+    if (!choicePrompt.selection || choicePrompt.selection === "__abort") {
+      console.log("Commit cancelled.");
+      return;
+    }
+    finalMessage = String(choicePrompt.selection);
+    if (choicePrompt.selection === "__custom") {
+      const { customMessage } = await (0, import_prompts.default)(
+        {
+          type: "text",
+          name: "customMessage",
+          message: "Enter commit message",
+          validate: (value) => value.trim().length > 0 ? true : "Commit message is required."
+        },
+        promptOptions
+      );
+      finalMessage = String(customMessage || "").trim();
+    }
+  }
+  if (!finalMessage) {
+    throw new Error("Commit message is empty.");
+  }
+  if (!yes) {
+    const { confirm } = await (0, import_prompts.default)(
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `Commit with message:
+${finalMessage}
+Proceed?`,
+        initial: true
+      },
+      promptOptions
+    );
+    if (!confirm) {
+      console.log("Commit cancelled.");
+      return;
+    }
+  }
+  if (dryRun) {
+    console.log(`[dry-run] ${finalMessage}`);
+    return;
+  }
+  await commitWithMessage(repoRoot, finalMessage);
+  console.log(`Commit created: ${finalMessage}`);
+}
+
+// src/commands/init.ts
+var import_prompts2 = __toESM(require("prompts"));
+var formatChoices = [
+  {
+    value: "conventional-scope",
+    title: "Conventional Commits (type(scope): subject)",
+    description: "Best for structured history with scopes.",
+    instructions: [
+      "Use Conventional Commits: type(scope): subject.",
+      "Allowed types: feat, fix, docs, style, refactor, perf, test, chore, ci, build.",
+      "Subject <= 72 chars, imperative mood, no trailing period."
+    ].join("\n")
+  },
+  {
+    value: "conventional",
+    title: "Conventional Commits (type: subject)",
+    description: "Structured without scopes.",
+    instructions: [
+      "Use Conventional Commits: type: subject.",
+      "Allowed types: feat, fix, docs, style, refactor, perf, test, chore, ci, build.",
+      "Subject <= 72 chars, imperative mood, no trailing period."
+    ].join("\n")
+  },
+  {
+    value: "short",
+    title: "Short imperative summary",
+    description: "Simple single-line format.",
+    instructions: [
+      "Single-line summary, imperative mood, <= 72 chars, no trailing period."
+    ].join("\n")
+  },
+  {
+    value: "detailed",
+    title: "Detailed subject + body",
+    description: "Subject line plus body details.",
+    instructions: [
+      "Subject <= 72 chars, imperative mood, no trailing period.",
+      "Blank line.",
+      "Body with bullet list of key changes (wrap at 100 chars)."
+    ].join("\n")
+  },
+  {
+    value: "custom",
+    title: "Custom format",
+    description: "Provide your own instructions."
+  }
+];
+var promptOptions2 = {
+  onCancel: () => {
+    throw new Error("Cancelled");
+  }
+};
+function hasGlobalDefaults(config) {
+  return Boolean(
+    config.model || config.format || config.instructions || typeof config.temperature === "number" || typeof config.maxTokens === "number"
+  );
+}
+async function runInit({ cwd, configPath }) {
+  var _a;
+  const isRepo = await isGitRepo(cwd);
+  if (!isRepo) {
+    throw new Error("Not a git repository. Run inside a git project.");
+  }
+  const repoRoot = await getRepoRoot(cwd);
+  const resolvedConfigPath = resolveConfigPath(repoRoot, configPath);
+  const existingConfig = await loadGlobalConfig(resolvedConfigPath, {
+    allowMissing: true
+  });
+  const { format } = await (0, import_prompts2.default)(
+    {
+      type: "select",
+      name: "format",
+      message: "Choose commit message format",
+      choices: formatChoices.map((choice) => ({
+        title: choice.title,
+        value: choice.value,
+        description: choice.description
+      })),
+      initial: 0
+    },
+    promptOptions2
+  );
+  const selected = formatChoices.find((choice) => choice.value === format);
+  if (!selected) {
+    throw new Error("Invalid format selection.");
+  }
+  let baseInstructions = selected.instructions ?? "";
+  if (selected.value === "custom") {
+    const { customInstructions } = await (0, import_prompts2.default)(
+      {
+        type: "text",
+        name: "customInstructions",
+        message: "Describe the commit message format",
+        validate: (value) => value.trim().length > 0 ? true : "Please enter instructions."
+      },
+      promptOptions2
+    );
+    baseInstructions = String(customInstructions || "").trim();
+  }
+  const { extraInstructions } = await (0, import_prompts2.default)(
+    {
+      type: "text",
+      name: "extraInstructions",
+      message: "Additional instructions (optional)",
+      initial: ""
+    },
+    promptOptions2
+  );
+  const extra = String(extraInstructions || "").trim();
+  const instructions = extra ? `${baseInstructions}
+${extra}` : baseInstructions;
+  const { model } = await (0, import_prompts2.default)(
+    {
+      type: "text",
+      name: "model",
+      message: "OpenRouter model",
+      initial: DEFAULT_MODEL,
+      validate: (value) => value.trim().length > 0 ? true : "Model is required."
+    },
+    promptOptions2
+  );
+  const { temperature } = await (0, import_prompts2.default)(
+    {
+      type: "number",
+      name: "temperature",
+      message: "Temperature (0-2)",
+      initial: DEFAULT_TEMPERATURE,
+      min: 0,
+      max: 2,
+      float: true
+    },
+    promptOptions2
+  );
+  const { maxTokens } = await (0, import_prompts2.default)(
+    {
+      type: "number",
+      name: "maxTokens",
+      message: `Max tokens (${MIN_OUTPUT_TOKENS}-${MAX_OUTPUT_TOKENS})`,
+      initial: DEFAULT_MAX_TOKENS,
+      min: MIN_OUTPUT_TOKENS,
+      max: MAX_OUTPUT_TOKENS
+    },
+    promptOptions2
+  );
+  const { scope } = await (0, import_prompts2.default)(
+    {
+      type: "select",
+      name: "scope",
+      message: "Apply settings to",
+      choices: [
+        {
+          title: "All projects (global defaults)",
+          value: "global",
+          description: "Used when a repo has no override"
+        },
+        {
+          title: "This repo only (override)",
+          value: "project",
+          description: "Use custom settings for this repository"
+        }
+      ],
+      initial: 0
+    },
+    promptOptions2
+  );
+  const targetScope = scope === "project" ? "project" : "global";
+  if (targetScope === "global" && hasGlobalDefaults(existingConfig)) {
+    const { overwrite } = await (0, import_prompts2.default)(
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "Global defaults already exist. Overwrite?",
+        initial: false
+      },
+      promptOptions2
+    );
+    if (!overwrite) {
+      console.log("Init cancelled.");
+      return;
+    }
+  }
+  if (targetScope === "project" && ((_a = existingConfig.projects) == null ? void 0 : _a[repoRoot])) {
+    const { overwrite } = await (0, import_prompts2.default)(
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "Config already exists for this repo. Overwrite?",
+        initial: false
+      },
+      promptOptions2
+    );
+    if (!overwrite) {
+      console.log("Init cancelled.");
+      return;
+    }
+  }
+  let globalApiKey = existingConfig.openrouterApiKey ?? "";
+  if (globalApiKey) {
+    const { reuseKey } = await (0, import_prompts2.default)(
+      {
+        type: "confirm",
+        name: "reuseKey",
+        message: "Use existing global OpenRouter API key?",
+        initial: true
+      },
+      promptOptions2
+    );
+    if (!reuseKey) {
+      const { apiKey } = await (0, import_prompts2.default)(
+        {
+          type: "password",
+          name: "apiKey",
+          message: "OpenRouter API key",
+          validate: (value) => value.trim().length > 0 ? true : "API key is required."
+        },
+        promptOptions2
+      );
+      globalApiKey = String(apiKey || "").trim();
+    }
+  } else {
+    const { apiKey } = await (0, import_prompts2.default)(
+      {
+        type: "password",
+        name: "apiKey",
+        message: "OpenRouter API key",
+        validate: (value) => value.trim().length > 0 ? true : "API key is required."
+      },
+      promptOptions2
+    );
+    globalApiKey = String(apiKey || "").trim();
+  }
+  const projectConfig = {
+    model: String(model || DEFAULT_MODEL).trim(),
+    format: String(format || "custom"),
+    instructions: instructions.trim(),
+    temperature: typeof temperature === "number" && !Number.isNaN(temperature) ? temperature : DEFAULT_TEMPERATURE,
+    maxTokens: typeof maxTokens === "number" && !Number.isNaN(maxTokens) ? Math.round(maxTokens) : DEFAULT_MAX_TOKENS
+  };
+  const updatedConfig = {
+    ...existingConfig,
+    projects: {
+      ...existingConfig.projects ?? {}
+    }
+  };
+  updatedConfig.openrouterApiKey = globalApiKey;
+  if (targetScope === "global") {
+    updatedConfig.model = projectConfig.model;
+    updatedConfig.format = projectConfig.format;
+    updatedConfig.instructions = projectConfig.instructions;
+    updatedConfig.temperature = projectConfig.temperature;
+    updatedConfig.maxTokens = projectConfig.maxTokens;
+  } else {
+    updatedConfig.projects[repoRoot] = projectConfig;
+  }
+  await saveGlobalConfig(resolvedConfigPath, updatedConfig);
+  console.log(`Config saved to ${resolvedConfigPath}`);
+  if (targetScope === "global") {
+    console.log("Applied as global defaults for all projects.");
+  } else {
+    console.log(`Applied as override for ${repoRoot}.`);
+  }
+}
+
+// src/cli.ts
+async function run(argv = process.argv) {
+  const program = new import_commander.Command();
+  program.name("aicmt").description("AI-assisted git commits via OpenRouter").version("0.1.0");
+  program.command("init").description("Initialize aicmt in this repository").option("-c, --config <path>", "Path to global config file").action(async (options) => {
+    await runInit({ cwd: process.cwd(), configPath: options.config });
+  });
+  program.command("commit", { isDefault: true }).description("Generate and create a commit for staged changes").option("-c, --config <path>", "Path to global config file").option("--dry-run", "Show the chosen message without committing", false).option("-v, --verbose", "Show AI request and response logs", false).option("-y, --yes", "Skip prompts: stage all, pick first message", false).action(
+    async (options) => {
+      await runCommit({
+        cwd: process.cwd(),
+        configPath: options.config,
+        dryRun: Boolean(options.dryRun),
+        verbose: Boolean(options.verbose),
+        yes: Boolean(options.yes)
+      });
+    }
+  );
+  await program.parseAsync(argv);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});
+//# sourceMappingURL=cli.js.map