@thejeetsingh/kalcode 2.0.0

package/src/config.ts

@@ -0,0 +1,61 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import type { Config } from "./types.js";
+import { DEFAULT_MODEL, AVAILABLE_MODELS } from "./constants.js";
+
+const CONFIG_DIR = join(homedir(), ".kalcode");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+const KNOWN_MODEL_IDS = new Set(AVAILABLE_MODELS.map(m => m.id));
+
+export function loadConfig(): Config {
+  if (!existsSync(CONFIG_FILE)) {
+    return { apiKey: process.env.NVIDIA_NIM_KEY || "", model: DEFAULT_MODEL };
+  }
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    let model = parsed.model || DEFAULT_MODEL;
+
+    // Migrate old OpenRouter model IDs
+    if (model.includes(":free") || model.includes("openrouter/")) {
+      model = DEFAULT_MODEL;
+    }
+
+    // Ignore old OpenRouter keys
+    const apiKey = (parsed.apiKey && !parsed.apiKey.startsWith("sk-or-"))
+      ? parsed.apiKey
+      : (process.env.NVIDIA_NIM_KEY || "");
+    return { apiKey, model };
+  } catch {
+    return { apiKey: "", model: DEFAULT_MODEL };
+  }
+}
+
+export function saveConfig(config: Config): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+
+export function getApiKey(): string {
+  return loadConfig().apiKey;
+}
+
+export function setApiKey(key: string): void {
+  const config = loadConfig();
+  config.apiKey = key;
+  saveConfig(config);
+}
+
+export function getModel(): string {
+  return loadConfig().model;
+}
+
+export function setModel(model: string): void {
+  const config = loadConfig();
+  config.model = model;
+  saveConfig(config);
+}

package/src/constants.ts

@@ -0,0 +1,58 @@
+export const VERSION = "2.0.0";
+
+export const API_URL = "https://integrate.api.nvidia.com/v1/chat/completions";
+
+export const DEFAULT_MODEL = "qwen/qwen3-coder-480b-a35b-instruct";
+
+export const AVAILABLE_MODELS: { id: string; name: string; params: string }[] = [
+  { id: "qwen/qwen3-coder-480b-a35b-instruct", name: "Qwen3 Coder 480B", params: "480B MoE" },
+  { id: "mistralai/devstral-2-123b-instruct-2512", name: "Devstral 2 123B", params: "123B" },
+  { id: "deepseek-ai/deepseek-v3.2", name: "DeepSeek V3.2", params: "685B" },
+  { id: "mistralai/mistral-large-3-675b-instruct-2512", name: "Mistral Large 3", params: "675B" },
+  { id: "qwen/qwen3.5-397b-a17b", name: "Qwen 3.5 397B", params: "397B MoE" },
+  { id: "moonshotai/kimi-k2-instruct", name: "Kimi K2", params: "1T MoE" },
+  { id: "z-ai/glm5", name: "GLM 5", params: "744B MoE" },
+  { id: "nvidia/llama-3.1-nemotron-ultra-253b-v1", name: "Nemotron Ultra", params: "253B" },
+  { id: "meta/llama-3.1-405b-instruct", name: "Llama 3.1 405B", params: "405B" },
+  { id: "minimaxai/minimax-m2.5", name: "MiniMax M2.5", params: "230B" },
+];
+
+export const MAX_LOOP_ITERATIONS = 50;
+export const MAX_OUTPUT_BYTES = 50 * 1024;
+export const DEFAULT_COMMAND_TIMEOUT = 30_000;
+export const MAX_COMMAND_TIMEOUT = 45_000;
+export const MAX_FILE_SIZE = 1024 * 1024;
+export const DEFAULT_LINE_LIMIT = 2000;
+export const MAX_GREP_RESULTS = 50;
+export const MAX_GLOB_RESULTS = 1000;
+export const MAX_DIR_ENTRIES = 500;
+export const MAX_DIR_DEPTH = 3;
+export const RATE_LIMIT_WINDOW = 60_000;
+export const RATE_LIMIT_MAX = 60;
+export const MAX_RETRIES = 3;
+export const RETRY_BASE_DELAY = 5_000;
+
+export function buildSystemPrompt(cwd: string): string {
+  return `You are kalcode, a CLI coding agent. You help users with software engineering tasks.
+
+IMPORTANT: Your working directory is ${cwd}
+ALL file operations MUST be relative to or inside this directory.
+NEVER create or modify files outside of ${cwd} unless the user explicitly provides an absolute path elsewhere.
+
+Tools available:
+- readFile: Read file contents (line numbers included)
+- writeFile: Create/overwrite files
+- editFile: Search/replace edits to existing files
+- runCommand: Execute shell commands (30s timeout)
+- grep: Search file contents with regex
+- glob: Find files by glob pattern
+- listDirectory: List directory contents
+
+Rules:
+- Read before editing. Use editFile for surgical changes, writeFile for new files.
+- Be concise. Lead with actions, not explanations.
+- Use relative paths from cwd. For tool calls, prefix paths with ${cwd}/ if using absolute paths.
+- When done, briefly summarize what you changed.
+- For dangerous operations (rm, git push, etc), warn the user first.
+- Do NOT explore directories outside the working directory.`;
+}

package/src/git/git.ts

@@ -0,0 +1,86 @@
+import { existsSync } from "fs";
+import { join } from "path";
+
+export function isGitRepo(cwd: string = process.cwd()): boolean {
+  return existsSync(join(cwd, ".git"));
+}
+
+async function run(args: string[], cwd?: string): Promise<{ ok: boolean; stdout: string; stderr: string }> {
+  try {
+    const proc = Bun.spawn(["git", ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      cwd: cwd || process.cwd(),
+    });
+    const [stdoutBuf, stderrBuf] = await Promise.all([
+      new Response(proc.stdout).arrayBuffer(),
+      new Response(proc.stderr).arrayBuffer(),
+    ]);
+    const exitCode = await proc.exited;
+    return {
+      ok: exitCode === 0,
+      stdout: new TextDecoder().decode(stdoutBuf).trim(),
+      stderr: new TextDecoder().decode(stderrBuf).trim(),
+    };
+  } catch (err) {
+    return { ok: false, stdout: "", stderr: String(err) };
+  }
+}
+
+export async function gitStatus(): Promise<string> {
+  const r = await run(["status", "--short"]);
+  return r.ok ? (r.stdout || "Clean working tree") : `git error: ${r.stderr}`;
+}
+
+export async function gitDiff(staged = false): Promise<string> {
+  const args = staged ? ["diff", "--staged"] : ["diff"];
+  const r = await run(args);
+  return r.ok ? (r.stdout || "No changes") : `git error: ${r.stderr}`;
+}
+
+export async function gitDiffSummary(): Promise<string> {
+  const r = await run(["diff", "--stat"]);
+  const rs = await run(["diff", "--staged", "--stat"]);
+  let out = "";
+  if (r.stdout) out += `Unstaged:\n${r.stdout}\n`;
+  if (rs.stdout) out += `Staged:\n${rs.stdout}`;
+  return out || "No changes";
+}
+
+export async function gitLog(count = 5): Promise<string> {
+  const r = await run(["log", `--oneline`, `-${count}`]);
+  return r.ok ? (r.stdout || "No commits yet") : `git error: ${r.stderr}`;
+}
+
+export async function gitCommit(message: string): Promise<{ ok: boolean; output: string }> {
+  // Stage all changes
+  await run(["add", "-A"]);
+  const r = await run(["commit", "-m", message]);
+  return { ok: r.ok, output: r.ok ? r.stdout : r.stderr };
+}
+
+export async function gitUndo(): Promise<{ ok: boolean; output: string }> {
+  // Check if there's a commit to undo
+  const log = await run(["log", "--oneline", "-1"]);
+  if (!log.ok || !log.stdout) {
+    return { ok: false, output: "No commits to undo" };
+  }
+
+  const r = await run(["reset", "--soft", "HEAD~1"]);
+  if (r.ok) {
+    // Also unstage
+    await run(["reset", "HEAD"]);
+    return { ok: true, output: `Undid: ${log.stdout}` };
+  }
+  return { ok: false, output: r.stderr };
+}
+
+export async function gitCurrentBranch(): Promise<string> {
+  const r = await run(["branch", "--show-current"]);
+  return r.ok ? r.stdout : "unknown";
+}
+
+export async function hasPendingChanges(): Promise<boolean> {
+  const r = await run(["status", "--porcelain"]);
+  return r.ok && r.stdout.length > 0;
+}

package/src/index.ts

@@ -0,0 +1,403 @@
+import { parseArgs } from "util";
+import { writeFileSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+import { VERSION, AVAILABLE_MODELS } from "./constants.js";
+import { loadConfig, setApiKey, setModel, saveConfig } from "./config.js";
+import { initHistory, clearHistory, getLastUserMessage, removeLastExchange } from "./agent/history.js";
+import { runAgentLoop, setCompact, getCompact, setAskMode, getAskMode, interruptAgent } from "./agent/loop.js";
+import { renderWelcome, renderHelp, renderError, renderSeparator, renderHints } from "./ui/terminal.js";
+import { pickModel } from "./ui/model-picker.js";
+import { createInput } from "./ui/input.js";
+import { getSkills, searchSkills, renderSkillsList } from "./ui/skills.js";
+import { setPermissionLevel, getPermissionLevel } from "./agent/permissions.js";
+import { addFileToContext, dropFileFromContext, listContextFiles, clearContextFiles } from "./agent/context.js";
+import { getMemoryFileName } from "./agent/memory.js";
+import { isGitRepo, gitUndo, gitDiffSummary, gitLog, gitStatus, gitCommit } from "./git/git.js";
+import * as readline from "readline";
+
+const REPL_COMMANDS: { cmd: string; desc: string }[] = [
+  { cmd: "/help", desc: "Show help" },
+  { cmd: "/clear", desc: "Clear conversation + context" },
+  { cmd: "/retry", desc: "Retry last message" },
+  { cmd: "/model", desc: "Show/switch model" },
+  { cmd: "/compact", desc: "Toggle compact output" },
+  { cmd: "/ask", desc: "Toggle read-only mode" },
+  { cmd: "/auto", desc: "Toggle auto-accept permissions" },
+  { cmd: "/skills", desc: "List skills" },
+  { cmd: "/add", desc: "Add file to context" },
+  { cmd: "/drop", desc: "Remove file from context" },
+  { cmd: "/files", desc: "List context files" },
+  { cmd: "/diff", desc: "Show uncommitted changes" },
+  { cmd: "/status", desc: "Git status" },
+  { cmd: "/log", desc: "Recent commits" },
+  { cmd: "/undo", desc: "Undo last commit" },
+  { cmd: "/commit", desc: "Commit all changes" },
+  { cmd: "/init", desc: "Create KALCODE.md" },
+  { cmd: "/exit", desc: "Quit" },
+  { cmd: "/quit", desc: "Quit" },
+  { cmd: "/q", desc: "Quit" },
+];
+
+export async function main(): Promise<void> {
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" },
+      model: { type: "string", short: "m" },
+      "set-key": { type: "boolean" },
+      "set-model": { type: "string" },
+      compact: { type: "boolean" },
+      "auto-accept": { type: "boolean" },
+      ask: { type: "boolean" },
+    },
+    allowPositionals: true,
+    strict: true,
+  });
+
+  if (values.version) {
+    console.log(`kalcode v${VERSION}`);
+    return;
+  }
+
+  if (values.help) {
+    printHelp();
+    return;
+  }
+
+  if (values["set-key"]) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const key = await new Promise<string>((resolve) => {
+      rl.question(chalk.dim("  NVIDIA NIM API key: "), (ans) => { rl.close(); resolve(ans.trim()); });
+    });
+    if (key) { setApiKey(key); console.log(chalk.green("  ✓ Saved to ~/.kalcode/config.json")); }
+    else { console.log(chalk.yellow("  No key provided.")); }
+    return;
+  }
+
+  if (values["set-model"]) {
+    setModel(values["set-model"]);
+    console.log(chalk.green(`  ✓ Default model: ${values["set-model"]}`));
+    return;
+  }
+
+  const config = loadConfig();
+  if (values.model) config.model = values.model;
+  if (values.compact) setCompact(true);
+  if (values["auto-accept"]) setPermissionLevel("auto");
+  if (values.ask) setAskMode(true);
+  const proxyUrl = (process.env.KALCODE_PROXY_URL || "").trim();
+  const proxyMode = proxyUrl.length > 0;
+
+  // API key check (skip when using proxy mode)
+  if (!proxyMode && !config.apiKey) {
+    console.log("");
+    console.log(chalk.yellow("  No API key found."));
+    console.log(chalk.dim("  Get one at https://build.nvidia.com (NVIDIA NIM)"));
+    console.log("");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const key = await new Promise<string>((resolve) => {
+      rl.question(chalk.dim("  NVIDIA NIM API key: "), (ans) => { rl.close(); resolve(ans.trim()); });
+    });
+    if (!key) { console.log(chalk.red("  API key required.")); return; }
+    setApiKey(key);
+    config.apiKey = key;
+    console.log(chalk.green("  ✓ Saved."));
+    console.log("");
+  }
+
+  await initHistory();
+
+  // Single-shot mode
+  if (positionals.length > 0) {
+    await runAgentLoop(config.apiKey, config.model, positionals.join(" "));
+    return;
+  }
+
+  // ─── Interactive REPL ─────────────────────────────────────────────
+  renderWelcome(config.model);
+
+  // Status context
+  const statusParts: string[] = [];
+  const memFile = getMemoryFileName(process.cwd());
+  if (memFile) statusParts.push(`memory: ${memFile}`);
+  if (isGitRepo()) statusParts.push("git: repo detected");
+  if (proxyMode) statusParts.push("api: proxy");
+  if (statusParts.length > 0) {
+    console.log(chalk.dim(`  ${statusParts.join("  ·  ")}`));
+  }
+
+  renderSeparator();
+  renderHints();
+
+  // Ctrl+C handling
+  let agentRunning = false;
+  process.on("SIGINT", () => {
+    if (agentRunning) {
+      interruptAgent();
+    } else {
+      console.log(chalk.dim("\n  Goodbye."));
+      process.exit(0);
+    }
+  });
+
+  const input = createInput(REPL_COMMANDS.map((c) => c.cmd));
+
+  while (true) {
+    let userInput: string;
+    try {
+      userInput = await input.prompt();
+    } catch {
+      await new Promise(r => setTimeout(r, 50));
+      continue;
+    }
+
+    if (!userInput) continue;
+
+    if (userInput.startsWith("/")) {
+      const parts = userInput.split(/\s+/);
+      const rawCmd = parts[0]!.toLowerCase();
+      const arg = parts.slice(1).join(" ");
+      const commandNames = REPL_COMMANDS.map((c) => c.cmd);
+
+      if (rawCmd === "/") {
+        renderSlashCommandMenu(commandNames);
+        continue;
+      }
+
+      let cmd = rawCmd;
+      if (!commandNames.includes(rawCmd)) {
+        const matches = commandNames.filter((c) => c.startsWith(rawCmd));
+        if (matches.length === 1) {
+          cmd = matches[0]!;
+          console.log(chalk.dim(`  → ${rawCmd} resolved to ${cmd}`));
+        } else if (matches.length > 1) {
+          renderSlashCommandMenu(matches);
+          continue;
+        } else {
+          console.log(chalk.dim(`  Unknown command: ${rawCmd}. Type / for command list.`));
+          continue;
+        }
+      }
+
+      switch (cmd) {
+        case "/exit": case "/quit": case "/q":
+          console.log(chalk.dim("  Goodbye."));
+          input.close();
+          return;
+
+        case "/help":
+          renderHelp();
+          continue;
+
+        case "/clear":
+          clearHistory();
+          clearContextFiles();
+          console.log(chalk.dim("  Conversation cleared."));
+          continue;
+
+        case "/retry": {
+          const lastMsg = getLastUserMessage();
+          if (!lastMsg) { console.log(chalk.dim("  Nothing to retry.")); continue; }
+          removeLastExchange();
+          console.log(chalk.dim(`  Retrying: ${lastMsg.slice(0, 60)}${lastMsg.length > 60 ? "…" : ""}`));
+          // Close readline before agent run so permission keypresses do not leak into prompt input.
+          input.close();
+          agentRunning = true;
+          await runAgentLoop(config.apiKey, config.model, lastMsg);
+          agentRunning = false;
+          continue;
+        }
+
+        case "/compact":
+          setCompact(!getCompact());
+          console.log(chalk.dim(`  Compact: ${getCompact() ? "on" : "off"}`));
+          continue;
+
+        case "/ask":
+          setAskMode(!getAskMode());
+          console.log(chalk.dim(`  Read-only mode: ${getAskMode() ? "on" : "off"}`));
+          continue;
+
+        case "/auto":
+          setPermissionLevel(getPermissionLevel() === "auto" ? "ask" : "auto");
+          console.log(chalk.dim(`  Auto-accept: ${getPermissionLevel() === "auto" ? "on" : "off"}`));
+          continue;
+
+        case "/model":
+          if (arg) {
+            config.model = arg;
+            saveConfig(config);
+            console.log(chalk.green(`  ✓ Model: ${arg}`));
+          } else {
+            // Close readline before opening raw-mode picker to avoid keypress buffering issues.
+            input.close();
+            const picked = await pickModel(AVAILABLE_MODELS, config.model);
+            if (picked && picked !== config.model) {
+              config.model = picked;
+              saveConfig(config);
+              console.log(chalk.green(`  ✓ Switched to ${picked}`));
+            } else if (picked) {
+              console.log(chalk.dim(`  Already using ${picked}`));
+            } else {
+              console.log(chalk.dim("  Cancelled."));
+            }
+          }
+          continue;
+
+        case "/skills": {
+          const skills = arg ? searchSkills(arg) : getSkills();
+          renderSkillsList(skills, arg);
+          continue;
+        }
+
+        case "/add":
+          if (!arg) { console.log(chalk.dim("  Usage: /add <file>")); continue; }
+          console.log(chalk.dim(`  ${addFileToContext(arg)}`));
+          continue;
+
+        case "/drop":
+          if (!arg) { console.log(chalk.dim("  Usage: /drop <file>")); continue; }
+          console.log(chalk.dim(`  ${dropFileFromContext(arg)}`));
+          continue;
+
+        case "/files": {
+          const files = listContextFiles();
+          if (files.length === 0) { console.log(chalk.dim("  No files in context. Use /add <file>")); }
+          else { files.forEach((f) => console.log(chalk.dim(`  · ${f}`))); }
+          continue;
+        }
+
+        case "/diff":
+          if (!isGitRepo()) { console.log(chalk.dim("  Not a git repo.")); continue; }
+          console.log(chalk.dim(await gitDiffSummary()));
+          continue;
+
+        case "/status":
+          if (!isGitRepo()) { console.log(chalk.dim("  Not a git repo.")); continue; }
+          console.log(chalk.dim(await gitStatus()));
+          continue;
+
+        case "/log":
+          if (!isGitRepo()) { console.log(chalk.dim("  Not a git repo.")); continue; }
+          console.log(chalk.dim(await gitLog()));
+          continue;
+
+        case "/undo":
+          if (!isGitRepo()) { console.log(chalk.dim("  Not a git repo.")); continue; }
+          const undoResult = await gitUndo();
+          console.log(undoResult.ok ? chalk.green(`  ✓ ${undoResult.output}`) : chalk.red(`  ✗ ${undoResult.output}`));
+          continue;
+
+        case "/commit": {
+          if (!isGitRepo()) { console.log(chalk.dim("  Not a git repo.")); continue; }
+          const msg = arg || "kalcode changes";
+          const commitResult = await gitCommit(msg);
+          console.log(commitResult.ok ? chalk.green(`  ✓ ${commitResult.output}`) : chalk.red(`  ✗ ${commitResult.output}`));
+          continue;
+        }
+
+        case "/init": {
+          const path = join(process.cwd(), "KALCODE.md");
+          const template = `# Project Conventions
+
+## Tech Stack
+<!-- e.g., TypeScript, React, Node.js -->
+
+## Architecture
+<!-- Brief description of project structure -->
+
+## Coding Style
+<!-- e.g., Use functional components, prefer const, etc. -->
+
+## Important Files
+<!-- Key files the agent should know about -->
+
+## Rules
+<!-- Any rules the agent should follow -->
+`;
+          writeFileSync(path, template);
+          console.log(chalk.green("  ✓ Created KALCODE.md — edit it with your project conventions"));
+          continue;
+        }
+
+        default:
+          console.log(chalk.dim(`  Unknown command: ${cmd}. Type /help`));
+          continue;
+      }
+    }
+
+    // Close readline before agent run so permission keypresses do not leak into prompt input.
+    input.close();
+    agentRunning = true;
+    await runAgentLoop(config.apiKey, config.model, userInput);
+    agentRunning = false;
+  }
+
+  input.close();
+}
+
+function printHelp(): void {
+  console.log(`
+${chalk.bold("kalcode")} — CLI coding agent powered by NVIDIA NIM
+
+${chalk.bold("Usage:")}
+  kalcode [options] [prompt]
+
+${chalk.bold("Options:")}
+  -h, --help           Show this help
+  -v, --version        Show version
+  -m, --model <id>     Use a specific model
+  --set-key            Set NVIDIA NIM API key
+  --set-model <id>     Set default model
+  --compact            Compact output
+  --auto-accept        Skip permission prompts
+  --ask                Read-only mode (no writes)
+
+${chalk.bold("REPL commands:")}
+  /help                Show help
+  /model [id]          Show or switch model
+  /clear               Clear conversation + context
+  /retry               Retry last message
+  /compact             Toggle compact output
+  /ask                 Toggle read-only mode
+  /auto                Toggle auto-accept permissions
+  /skills [query]      List skills (filter optional)
+  /add <file>          Add file to context
+  /drop <file>         Remove file from context
+  /files               List context files
+
+${chalk.bold("Git commands:")}
+  /diff                Show uncommitted changes
+  /status              Git status
+  /log                 Recent commits
+  /undo                Undo last commit (soft reset)
+  /commit [msg]        Commit all changes
+
+${chalk.bold("Project:")}
+  /init                Create KALCODE.md conventions file
+  /exit                Quit
+
+${chalk.bold("Models (NVIDIA NIM):")}
+${AVAILABLE_MODELS.map(m => `  ${chalk.dim(m.name.padEnd(22))} ${m.id}`).join("\n")}
+
+${chalk.bold("Examples:")}
+  kalcode "fix the bug in main.ts"
+  kalcode -m nvidia/llama-3.1-405b-instruct "explain this"
+  kalcode --ask "explain this codebase"
+  /                      Show all slash commands
+  /he                    Auto-resolve to /help when unique
+`);
+}
+
+function renderSlashCommandMenu(commands: string[]): void {
+  console.log("");
+  console.log(chalk.bold("  Slash commands"));
+  for (const cmd of commands) {
+    const def = REPL_COMMANDS.find((c) => c.cmd === cmd);
+    if (!def) continue;
+    console.log(`  ${chalk.bold(cmd.padEnd(12))}${chalk.dim(def.desc)}`);
+  }
+  console.log("");
+}