@ayoxx/kundex 1.0.0 → 2.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ayoxx/kundex",
-  "version": "1.0.0",
-  "description": "Kundex — a terminal-based AI coding agent CLI and SDK, powered by Groq.",
+  "version": "2.0.0",
+  "description": "Kundex — a terminal-based AI coding agent CLI and SDK, powered by Mistral and Heavstal AI.",
   "type": "module",
   "bin": {
     "kundex": "./bin/kundex.mjs"

package/src/index.ts

@@ -2,10 +2,8 @@ import { loadConfig, saveConfig, resolveBaseUrl } from "./config";
 import { runLogin } from "./login";
 import { runRepl } from "./repl";
 import { Kundex } from "./sdk";
-import fs from "node:fs/promises";
-import path from "node:path";
 
-const VERSION = "0.2.0";
+const VERSION = "1.0.0";
 
 // ─── Help text ────────────────────────────────────────────────────────────────
 
@@ -23,18 +21,6 @@ const HELP = `
   (no command)                     Start the interactive AI coding agent REPL
   run <message>                    Run a single agent turn (non-interactive)
 
-\x1b[1mWorkspaces:\x1b[0m
-  workspace list                   List all your agent workspaces
-  workspace new [cwd]              Create a new workspace (default: current dir)
-  workspace delete <id>            Delete a workspace
-
-\x1b[1mFiles:\x1b[0m
-  files list <wsId>                List files in a workspace
-  files get <wsId> <path>          Print a file's content to stdout
-  files push <wsId> <localPath>    Upload a local file to a workspace
-  files push <wsId> <localPath> <remotePath>
-  files pull <wsId> <remotePath>   Download a workspace file to stdout (or --out)
-
 \x1b[1mModels:\x1b[0m
   models                           List available models
 
@@ -52,14 +38,7 @@ const HELP = `
   kundex                                       # start REPL in current directory
   kundex run "Fix all TypeScript errors"
   kundex models
-  kundex workspace list
-  kundex workspace new /path/to/project
-  kundex workspace delete 42
-  kundex files list 17
-  kundex files get 17 src/index.ts
-  kundex files push 17 ./README.md
-  kundex files pull 17 src/index.ts --out ./downloaded.ts
-  kundex config set model openai/gpt-oss-120b
+  kundex config set model codestral-latest
   kundex config set baseUrl https://api.kundex.com.ng
 `.trim();
 
@@ -84,8 +63,6 @@ function header(msg: string) { console.log(`\n${c.bold}${c.cyan}  ${msg}${c.rese
 
 const PROVIDER_DISPLAY: Record<string, string> = {
   heavstal: "Heavstal",
-  gemini:   "Gemini",
-  groq:     "Groq",
   mistral:  "Mistral",
 };
 
@@ -101,7 +78,6 @@ async function cmdModels(config: ReturnType<typeof loadConfig>, baseUrl: string)
     console.log(`\n  ${c.dim}${"Name".padEnd(nameWidth)}  ${"ID".padEnd(idWidth)}  ${"Provider".padEnd(providerWidth)}  Context${c.reset}`);
     console.log(`  ${c.dim}${"─".repeat(nameWidth + idWidth + providerWidth + 18)}${c.reset}`);
 
-    // Group by provider for cleaner output
     const grouped: Record<string, typeof models> = {};
     const order: string[] = [];
     for (const m of models) {
@@ -133,209 +109,6 @@ async function cmdModels(config: ReturnType<typeof loadConfig>, baseUrl: string)
   }
 }
 
-async function cmdWorkspaceList(config: ReturnType<typeof loadConfig>, baseUrl: string) {
-  const kundex = new Kundex({ apiKey: config.apiKey!, baseUrl });
-  header("Workspaces");
-  try {
-    const sessions = await kundex.agent.listSessions();
-
-    if (!sessions.length) {
-      dim("No workspaces yet. Create one with: kundex workspace new <directory>");
-      return;
-    }
-
-    console.log(`\n  ${c.dim}${"ID".padEnd(6)}  ${"Name".padEnd(28)}  ${"Directory".padEnd(34)}  Model${c.reset}`);
-    console.log(`  ${c.dim}${"─".repeat(90)}${c.reset}`);
-    for (const s of sessions) {
-      const cwd = (s.cwd ?? "").length > 32 ? `…${s.cwd.slice(-31)}` : (s.cwd ?? "");
-      const name = (s.name ?? `Workspace #${s.id}`).slice(0, 26);
-      console.log(`  ${c.bold}${String(s.id).padEnd(6)}${c.reset}  ${name.padEnd(28)}  ${c.dim}${cwd.padEnd(34)}  ${s.model}${c.reset}`);
-    }
-    console.log();
-  } catch (e) {
-    errMsg(`Failed to list workspaces: ${(e as Error).message}`);
-    process.exitCode = 1;
-  }
-}
-
-async function cmdWorkspaceNew(
-  config: ReturnType<typeof loadConfig>,
-  baseUrl: string,
-  args: string[],
-) {
-  const cwd = args[0] ?? process.cwd();
-
-  // Parse optional flags: --model <model>, --name <name>
-  let model = config.defaultModel ?? "openai/gpt-oss-120b";
-  let name: string | undefined;
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--model" && args[i + 1]) { model = args[++i]; }
-    else if (args[i] === "--name" && args[i + 1]) { name = args[++i]; }
-  }
-
-  const kundex = new Kundex({ apiKey: config.apiKey!, baseUrl });
-
-  try {
-    const session = await kundex.agent.createSession({ cwd, model, name });
-    ok(`Created workspace #${session.id}`);
-    dim(`Name:      ${session.name}`);
-    dim(`Directory: ${cwd}`);
-    dim(`Model:     ${session.model}`);
-    console.log();
-  } catch (e) {
-    errMsg(`Failed to create workspace: ${(e as Error).message}`);
-    process.exitCode = 1;
-  }
-}
-
-async function cmdWorkspaceDelete(
-  config: ReturnType<typeof loadConfig>,
-  baseUrl: string,
-  idStr: string,
-) {
-  const id = Number(idStr);
-  if (!Number.isFinite(id) || id <= 0) {
-    errMsg("Usage: kundex workspace delete <id>");
-    process.exitCode = 1;
-    return;
-  }
-
-  const kundex = new Kundex({ apiKey: config.apiKey!, baseUrl });
-
-  try {
-    await kundex.agent.deleteSession(id);
-    ok(`Deleted workspace #${id}`);
-  } catch (e) {
-    errMsg(`Failed to delete workspace: ${(e as Error).message}`);
-    process.exitCode = 1;
-  }
-}
-
-// ── Files ─────────────────────────────────────────────────────────────────────
-
-async function cmdFilesList(
-  config: ReturnType<typeof loadConfig>,
-  baseUrl: string,
-  wsIdStr: string,
-) {
-  const wsId = Number(wsIdStr);
-  if (!Number.isFinite(wsId) || wsId <= 0) {
-    errMsg("Usage: kundex files list <wsId>");
-    process.exitCode = 1;
-    return;
-  }
-
-  const kundex = new Kundex({ apiKey: config.apiKey!, baseUrl });
-  header(`Files in workspace #${wsId}`);
-
-  try {
-    const { files } = await kundex.files.list(wsId);
-    if (!files.length) {
-      dim("No files yet.");
-      return;
-    }
-
-    console.log(`\n  ${c.dim}${"Path".padEnd(44)}  ${"Size".padEnd(10)}  MIME${c.reset}`);
-    console.log(`  ${c.dim}${"─".repeat(80)}${c.reset}`);
-    for (const f of files) {
-      const size = f.size < 1024 ? `${f.size} B`
-        : f.size < 1024 * 1024 ? `${(f.size / 1024).toFixed(1)} KB`
-        : `${(f.size / 1024 / 1024).toFixed(1)} MB`;
-      const displayPath = f.path.length > 42 ? `…${f.path.slice(-41)}` : f.path;
-      console.log(`  ${displayPath.padEnd(44)}  ${size.padEnd(10)}  ${c.dim}${f.mimeType}${c.reset}`);
-    }
-    console.log();
-  } catch (e) {
-    errMsg(`Failed to list files: ${(e as Error).message}`);
-    process.exitCode = 1;
-  }
-}
-
-async function cmdFilesGet(
-  config: ReturnType<typeof loadConfig>,
-  baseUrl: string,
-  wsIdStr: string,
-  remotePath: string,
-) {
-  const wsId = Number(wsIdStr);
-  if (!Number.isFinite(wsId) || wsId <= 0 || !remotePath) {
-    errMsg("Usage: kundex files get <wsId> <path>");
-    process.exitCode = 1;
-    return;
-  }
-
-  const kundex = new Kundex({ apiKey: config.apiKey!, baseUrl });
-
-  try {
-    const file = await kundex.files.get(wsId, remotePath);
-    process.stdout.write(file.content ?? "");
-  } catch (e) {
-    errMsg(`Failed to get file: ${(e as Error).message}`);
-    process.exitCode = 1;
-  }
-}
-
-async function cmdFilesPush(
-  config: ReturnType<typeof loadConfig>,
-  baseUrl: string,
-  wsIdStr: string,
-  localPath: string,
-  remotePath?: string,
-) {
-  const wsId = Number(wsIdStr);
-  if (!Number.isFinite(wsId) || wsId <= 0 || !localPath) {
-    errMsg("Usage: kundex files push <wsId> <localPath> [remotePath]");
-    process.exitCode = 1;
-    return;
-  }
-
-  const kundex = new Kundex({ apiKey: config.apiKey!, baseUrl });
-  const destPath = remotePath ?? path.basename(localPath);
-
-  try {
-    const content = await fs.readFile(localPath, "utf-8");
-    const name = path.basename(destPath);
-    await kundex.files.upsert(wsId, { path: destPath, name, content });
-    ok(`Pushed ${localPath} → workspace #${wsId}:${destPath}`);
-  } catch (e) {
-    errMsg(`Failed to push file: ${(e as Error).message}`);
-    process.exitCode = 1;
-  }
-}
-
-async function cmdFilesPull(
-  config: ReturnType<typeof loadConfig>,
-  baseUrl: string,
-  wsIdStr: string,
-  remotePath: string,
-  outPath?: string,
-) {
-  const wsId = Number(wsIdStr);
-  if (!Number.isFinite(wsId) || wsId <= 0 || !remotePath) {
-    errMsg("Usage: kundex files pull <wsId> <remotePath> [--out <localPath>]");
-    process.exitCode = 1;
-    return;
-  }
-
-  const kundex = new Kundex({ apiKey: config.apiKey!, baseUrl });
-
-  try {
-    const file = await kundex.files.get(wsId, remotePath);
-    const content = file.content ?? "";
-
-    if (outPath) {
-      await fs.mkdir(path.dirname(outPath), { recursive: true });
-      await fs.writeFile(outPath, content, "utf-8");
-      ok(`Saved ${remotePath} → ${outPath} (${content.length} bytes)`);
-    } else {
-      process.stdout.write(content);
-    }
-  } catch (e) {
-    errMsg(`Failed to pull file: ${(e as Error).message}`);
-    process.exitCode = 1;
-  }
-}
-
 // ── Run (single-turn non-interactive) ─────────────────────────────────────────
 
 async function cmdRun(
@@ -350,26 +123,18 @@ async function cmdRun(
     return;
   }
 
-  // Parse optional flags: --model, --workspace, --cwd
-  let model = config.defaultModel ?? "openai/gpt-oss-120b";
-  let wsId: number | null = null;
+  let model = config.defaultModel ?? "codestral-latest";
   let cwd = process.cwd();
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--model" && args[i + 1]) model = args[++i];
-    else if ((args[i] === "--workspace" || args[i] === "-w") && args[i + 1]) wsId = Number(args[++i]);
     else if (args[i] === "--cwd" && args[i + 1]) cwd = args[++i];
   }
 
   const kundex = new Kundex({ apiKey: config.apiKey!, baseUrl });
-  let sessionId: number;
 
   try {
-    if (wsId !== null && Number.isFinite(wsId)) {
-      sessionId = wsId;
-    } else {
-      const session = await kundex.agent.createSession({ cwd, model });
-      sessionId = session.id;
-    }
+    const session = await kundex.agent.createSession({ cwd, model });
+    const sessionId = session.id;
 
     process.stdout.write(`\n`);
     const { executeToolCall } = await import("./tools");
@@ -379,7 +144,6 @@ async function cmdRun(
       (delta) => process.stdout.write(delta),
     );
 
-    // Handle tool calls in a loop until the turn is done
     while (!turn.done && turn.toolCalls && turn.toolCalls.length > 0) {
       for (const call of turn.toolCalls) {
         const { result, isError } = await executeToolCall(cwd, call);
@@ -435,6 +199,29 @@ function cmdLogout() {
   ok("Logged out. Run `kundex login` to authenticate again.");
 }
 
+// ─── API key prompt ──────────────────────────────────────────────────────────
+
+async function promptForApiKey(): Promise<string | null> {
+  const readline = await import("node:readline/promises");
+  const rl = readline.default.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    console.log(`\n${c.bold}${c.cyan}  Welcome to Kundex!${c.reset}`);
+    console.log(`${c.dim}  You need an API key to use the agent.${c.reset}`);
+    console.log(`${c.dim}  Get one at: https://kundex.com.ng/dashboard/api-keys${c.reset}\n`);
+    const answer = await rl.question(`${c.bold}  Enter your API key: ${c.reset}`);
+    const apiKey = answer.trim();
+    if (!apiKey) {
+      console.log(`${c.dim}  No key entered. Run \`kundex login\` later to set one.${c.reset}\n`);
+      return null;
+    }
+    saveConfig({ apiKey });
+    ok("API key saved.");
+    return apiKey;
+  } finally {
+    rl.close();
+  }
+}
+
 // ─── Main ─────────────────────────────────────────────────────────────────────
 
 async function main(): Promise<void> {
@@ -453,16 +240,25 @@ async function main(): Promise<void> {
     return;
   }
 
-  // No command — drop into REPL if logged in, else show help
+  // No command — start REPL, prompting for API key if needed
   if (!command) {
-    const config = loadConfig();
+    let config = loadConfig();
     const baseUrl = resolveBaseUrl(config);
+
+    if (!config.apiKey) {
+      const key = await promptForApiKey();
+      if (!key) {
+        console.log(HELP);
+        return;
+      }
+      config = loadConfig();
+    }
+
     if (config.apiKey && baseUrl) {
       await runRepl(config, config.apiKey, baseUrl);
       return;
     }
     console.log(HELP);
-    console.log(`\n${c.yellow}  Run \`kundex login\` to get started.${c.reset}\n`);
     return;
   }
 
@@ -477,25 +273,35 @@ async function main(): Promise<void> {
   }
 
   // Load config — required for all remaining commands
-  const config = loadConfig();
+  let config = loadConfig();
   const baseUrl = resolveBaseUrl(config);
 
   if (!config.apiKey || !baseUrl) {
-    errMsg('Not logged in. Run "kundex login" first.');
-    process.exitCode = 1;
-    return;
+    if (!config.apiKey) {
+      const key = await promptForApiKey();
+      if (!key) {
+        process.exitCode = 1;
+        return;
+      }
+      config = loadConfig();
+    }
+    if (!config.apiKey || !resolveBaseUrl(config)) {
+      errMsg('Not logged in. Run "kundex login" first.');
+      process.exitCode = 1;
+      return;
+    }
   }
 
   // Models
   if (command === "models") {
-    await cmdModels(config, baseUrl);
+    await cmdModels(config, resolveBaseUrl(config)!);
     return;
   }
 
   // Config
   if (command === "config") {
     if (sub === "show" || !sub) {
-      cmdConfigShow(config, baseUrl);
+      cmdConfigShow(config, resolveBaseUrl(config)!);
     } else if (sub === "set") {
       const [key, value] = rest;
       if (!key || !value) {
@@ -511,56 +317,15 @@ async function main(): Promise<void> {
     return;
   }
 
-  // Workspace
-  if (command === "workspace") {
-    if (sub === "list" || !sub) {
-      await cmdWorkspaceList(config, baseUrl);
-    } else if (sub === "new") {
-      await cmdWorkspaceNew(config, baseUrl, rest);
-    } else if (sub === "delete") {
-      await cmdWorkspaceDelete(config, baseUrl, rest[0]);
-    } else {
-      errMsg(`Unknown workspace subcommand "${sub}". Use: list, new, delete`);
-      process.exitCode = 1;
-    }
-    return;
-  }
-
-  // Files
-  if (command === "files") {
-    if (sub === "list") {
-      await cmdFilesList(config, baseUrl, rest[0]);
-    } else if (sub === "get") {
-      await cmdFilesGet(config, baseUrl, rest[0], rest[1]);
-    } else if (sub === "push") {
-      await cmdFilesPush(config, baseUrl, rest[0], rest[1], rest[2]);
-    } else if (sub === "pull") {
-      // Support --out flag
-      let outPath: string | undefined;
-      const remaining: string[] = [];
-      for (let i = 0; i < rest.length; i++) {
-        if (rest[i] === "--out" && rest[i + 1]) { outPath = rest[++i]; }
-        else remaining.push(rest[i]);
-      }
-      await cmdFilesPull(config, baseUrl, remaining[0], remaining[1], outPath);
-    } else {
-      errMsg(`Unknown files subcommand "${sub}". Use: list, get, push, pull`);
-      process.exitCode = 1;
-    }
-    return;
-  }
-
   // Run (single-turn agent)
   if (command === "run") {
-    // "kundex run <message>" — join remaining args as the message
     const allArgs = [sub, ...rest].filter(Boolean);
-    // Find message (everything before the first -- flag or flag-like arg)
     const flagStart = allArgs.findIndex((a) => a.startsWith("--"));
     const messageParts = flagStart >= 0 ? allArgs.slice(0, flagStart) : allArgs;
     const flagArgs = flagStart >= 0 ? allArgs.slice(flagStart) : [];
     const message = messageParts.join(" ").trim();
 
-    await cmdRun(config, baseUrl, message, flagArgs);
+    await cmdRun(config, resolveBaseUrl(config)!, message, flagArgs);
     return;
   }
 

package/src/repl.ts

@@ -18,14 +18,13 @@ const c = {
   blue:    "\x1b[34m",
   magenta: "\x1b[35m",
   white:   "\x1b[37m",
-  // Syntax-highlight colours (256-colour palette)
-  kw:      "\x1b[38;5;204m",  // keywords     – salmon/red
-  str:     "\x1b[38;5;150m",  // strings      – light green
-  num:     "\x1b[38;5;141m",  // numbers      – light purple
-  comment: "\x1b[38;5;244m",  // comments     – grey
-  fn:      "\x1b[38;5;117m",  // functions    – light blue
-  type_:   "\x1b[38;5;215m",  // types/decorators – orange
-  punct:   "\x1b[38;5;250m",  // punctuation  – light grey
+  kw:      "\x1b[38;5;204m",
+  str:     "\x1b[38;5;150m",
+  num:     "\x1b[38;5;141m",
+  comment: "\x1b[38;5;244m",
+  fn:      "\x1b[38;5;117m",
+  type_:   "\x1b[38;5;215m",
+  punct:   "\x1b[38;5;250m",
 };
 
 // ─── Per-language syntax highlighter (ANSI, no deps) ─────────────────────────
@@ -56,22 +55,15 @@ const KEYWORDS: Record<string, string[]> = {
 function buildRules(lang: string): LangRule[] {
   const kws = KEYWORDS[lang] || KEYWORDS["javascript"];
   return [
-    // Comments
     { pattern: /(#.*$|\/\/.*$|\/\*[\s\S]*?\*\/|"""[\s\S]*?"""|'''[\s\S]*?''')/gm, color: c.comment },
-    // Strings
     { pattern: /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g, color: c.str },
-    // Numbers
     { pattern: /\b(\d+\.?\d*(?:e[+-]?\d+)?)\b/g, color: c.num },
-    // Keywords (built from per-language list)
     { pattern: new RegExp(`\\b(${kws.join("|")})\\b`, "g"), color: c.kw },
-    // Function calls
     { pattern: /\b([a-zA-Z_]\w*)\s*(?=\()/g, color: c.fn },
-    // Type annotations (CamelCase identifiers)
     { pattern: /\b([A-Z][a-zA-Z0-9_]*)\b/g, color: c.type_ },
   ];
 }
 
-/** Apply regex-based ANSI syntax highlighting to a code string. */
 function syntaxHighlight(code: string, lang: string): string {
   const l = lang.toLowerCase();
   const normalised = ["tsx","ts"].includes(l) ? "typescript"
@@ -167,14 +159,11 @@ ${c.bold}Commands:${c.reset}
   /help               Show this help
   /model              Show the model for this session
   /clear              Start a fresh agent session
-  /workspace list     List all your workspaces
-  /workspace use <id> Switch to an existing workspace session
-  /files              List files in the current workspace
   /exit               Quit kundex
 
 ${c.bold}Tips:${c.reset}
-  • The agent can read, edit and search files, run commands, and use git.
-  • You will be asked to confirm any writes or shell commands before they run.
+  • The agent can read files, search code, run commands, and use git.
+  • You will be asked to confirm any shell commands before they run.
   • Responses stream in real-time — text appears as the model generates it.
   • Code blocks are syntax-highlighted in the terminal.
   • Press Ctrl+C to abort a running request.
@@ -199,10 +188,6 @@ function safeFileTree(cwd: string): string | undefined {
   }
 }
 
-/**
- * Spinner that writes to stdout with carriage-return to overwrite itself.
- * Call clear() to erase it before writing other output.
- */
 function createSpinner(label: string) {
   const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
   let frame = 0;
@@ -213,15 +198,11 @@ function createSpinner(label: string) {
   return {
     clear() {
       clearInterval(timer);
-      process.stdout.write("\r\x1b[2K"); // CR + erase line
+      process.stdout.write("\r\x1b[2K");
     },
   };
 }
 
-/**
- * Handle a completed AgentTurn: process any tool calls, stream tool-result turns.
- * All tool results are submitted using the streaming API so progress is visible.
- */
 async function handleTurn(
   kundex: Kundex,
   cwd: string,
@@ -238,7 +219,6 @@ async function handleTurn(
         process.stdout.write(`${c.red}  ✗ ${call.name}: ${result}${c.reset}\n`);
       }
 
-      // Show a spinner while waiting for the follow-up AI turn
       const sp = createSpinner("processing tool result…");
       let followUpText = "";
 
@@ -247,7 +227,6 @@ async function handleTurn(
           { sessionId, toolCallId: call.id, result, isError },
           (delta) => {
             if (!followUpText) {
-              // First token arrived — clear the spinner
               sp.clear();
               process.stdout.write("\n");
             }
@@ -267,7 +246,6 @@ async function handleTurn(
   }
 
   if (current.reply && !turn.toolCalls?.length) {
-    // Reply was already streamed inline; just print the closing rule
     process.stdout.write(`\n${c.dim}${"─".repeat(60)}${c.reset}\n\n`);
   } else if (current.reply) {
     printReply(current.reply);
@@ -296,15 +274,13 @@ ${c.bold}${c.cyan}  ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═
 export async function runRepl(config: KundexConfig, apiKey: string, baseUrl: string): Promise<void> {
   const cwd = process.cwd();
   const kundex = new Kundex({ apiKey, baseUrl });
-  const model = config.defaultModel ?? "openai/gpt-oss-120b";
+  const model = config.defaultModel ?? "codestral-latest";
 
   printBanner(cwd, model);
 
   let session = await kundex.agent.createSession({ cwd, model });
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 
-  // AbortController for the current in-progress request.
-  // Ctrl+C signals the controller and sends a SIGINT to abort the fetch.
   let currentAbort: AbortController | null = null;
 
   const sigintHandler = () => {
@@ -313,7 +289,6 @@ export async function runRepl(config: KundexConfig, apiKey: string, baseUrl: str
       process.stdout.write(`\n${c.yellow}  ⚡ Stopped.${c.reset}\n\n`);
       currentAbort = null;
     } else {
-      // Second Ctrl+C with no request in flight → exit
       console.log(`\n${c.dim}Goodbye!${c.reset}\n`);
       rl.close();
       process.exit(0);
@@ -328,7 +303,6 @@ export async function runRepl(config: KundexConfig, apiKey: string, baseUrl: str
       const input = raw.trim();
       if (!input) continue;
 
-      // ── REPL commands ───────────────────────────────────────────────────────
       if (input === "/exit" || input === "/quit") {
         console.log(`\n${c.dim}Goodbye!${c.reset}\n`);
         break;
@@ -344,69 +318,6 @@ export async function runRepl(config: KundexConfig, apiKey: string, baseUrl: str
         continue;
       }
 
-      // /workspace list
-      if (input === "/workspace list") {
-        try {
-          const sessions = await kundex.agent.listSessions();
-          if (!sessions.length) {
-            console.log(`${c.dim}  No workspaces yet.${c.reset}`);
-          } else {
-            console.log(`\n  ${c.dim}${"ID".padEnd(6)}  ${"Name".padEnd(26)}  CWD${c.reset}`);
-            console.log(`  ${c.dim}${"─".repeat(70)}${c.reset}`);
-            for (const s of sessions) {
-              const isActive = s.id === session.id ? ` ${c.cyan}← active${c.reset}` : "";
-              const name = (s.name ?? `Workspace #${s.id}`).slice(0, 24);
-              const cwd2 = (s.cwd ?? "").length > 30 ? `…${s.cwd.slice(-29)}` : s.cwd;
-              console.log(`  ${c.bold}${String(s.id).padEnd(6)}${c.reset}  ${name.padEnd(26)}  ${c.dim}${cwd2}${c.reset}${isActive}`);
-            }
-            console.log();
-          }
-        } catch (err) {
-          console.error(`${c.red}  error: ${(err as Error).message}${c.reset}`);
-        }
-        continue;
-      }
-
-      // /workspace use <id>
-      if (input.startsWith("/workspace use ")) {
-        const id = Number(input.slice("/workspace use ".length).trim());
-        if (!Number.isFinite(id) || id <= 0) {
-          console.error(`${c.red}  Invalid workspace ID.${c.reset}`);
-          continue;
-        }
-        try {
-          const s = await kundex.agent.getSession(id) as AgentSession;
-          session = s as any;
-          console.log(`\n${c.green}  ✓ Switched to workspace #${id} — ${s.name}${c.reset}\n`);
-        } catch (err) {
-          console.error(`${c.red}  error: ${(err as Error).message}${c.reset}`);
-        }
-        continue;
-      }
-
-      // /files
-      if (input === "/files") {
-        try {
-          const { files } = await kundex.files.list(session.id);
-          if (!files.length) {
-            console.log(`${c.dim}  No files in this workspace yet.${c.reset}`);
-          } else {
-            console.log(`\n  ${c.dim}${"Path".padEnd(40)}  Size${c.reset}`);
-            console.log(`  ${c.dim}${"─".repeat(52)}${c.reset}`);
-            for (const f of files) {
-              const size = f.size < 1024 ? `${f.size} B`
-                : f.size < 1024 * 1024 ? `${(f.size / 1024).toFixed(1)} KB`
-                : `${(f.size / 1024 / 1024).toFixed(1)} MB`;
-              console.log(`  ${f.path.padEnd(40)}  ${c.dim}${size}${c.reset}`);
-            }
-            console.log();
-          }
-        } catch (err) {
-          console.error(`${c.red}  error: ${(err as Error).message}${c.reset}`);
-        }
-        continue;
-      }
-
       // ── Agent message ────────────────────────────────────────────────────────
       currentAbort = new AbortController();
       const { signal } = currentAbort;
@@ -421,7 +332,6 @@ export async function runRepl(config: KundexConfig, apiKey: string, baseUrl: str
             context: {
               gitStatus: safeGitStatus(cwd),
               fileTree: safeFileTree(cwd),
-              openFiles: [],
             },
           },
           (delta) => {
@@ -437,12 +347,9 @@ export async function runRepl(config: KundexConfig, apiKey: string, baseUrl: str
 
         spinner.clear();
 
-        // If the response contained only tool calls (no streamed text), let
-        // handleTurn print the tool output and follow-up replies.
         if (turn.toolCalls?.length) {
           await handleTurn(kundex, cwd, session.id, turn, signal);
         } else if (streamedAnyText) {
-          // Text was streamed inline; just print the closing separator.
           process.stdout.write(`\n${c.dim}${"─".repeat(60)}${c.reset}\n\n`);
         } else if (turn.reply) {
           printReply(turn.reply);

package/src/sdk.ts

@@ -21,7 +21,7 @@ export interface ChatUsage {
 export interface ModelInfo {
   id: string;
   name: string;
-  /** Which inference provider serves this model (e.g. "heavstal", "groq", "gemini", "mistral"). */
+  /** Which inference provider serves this model (e.g. "heavstal", "mistral"). */
   provider?: string;
   contextWindow: number;
   inputPricePerMTok: number;

package/src/tools.ts

@@ -25,7 +25,6 @@ const c = {
   blue: "\x1b[34m",
   magenta: "\x1b[35m",
   white: "\x1b[37m",
-  bgDark: "\x1b[48;5;235m",
 };
 
 function header(label: string, value: string) {
@@ -34,34 +33,6 @@ function header(label: string, value: string) {
   );
 }
 
-function printDiff(oldContent: string | null, newContent: string, filePath: string) {
-  const oldLines = oldContent ? oldContent.split("\n") : [];
-  const newLines = newContent.split("\n");
-  const maxLines = Math.max(oldLines.length, newLines.length);
-  const LIMIT = 60;
-  const shown = Math.min(maxLines, LIMIT);
-
-  console.log(`\n${c.bold}${c.white}  ┌─ ${filePath} ─────────────────────────${c.reset}`);
-  for (let i = 0; i < shown; i++) {
-    const o = oldLines[i];
-    const n = newLines[i];
-    if (o === undefined) {
-      process.stdout.write(`${c.green}  + ${(i + 1).toString().padStart(4)}  ${n ?? ""}${c.reset}\n`);
-    } else if (n === undefined) {
-      process.stdout.write(`${c.red}  - ${(i + 1).toString().padStart(4)}  ${o ?? ""}${c.reset}\n`);
-    } else if (o !== n) {
-      process.stdout.write(`${c.red}  - ${(i + 1).toString().padStart(4)}  ${o}${c.reset}\n`);
-      process.stdout.write(`${c.green}  + ${(i + 1).toString().padStart(4)}  ${n}${c.reset}\n`);
-    } else {
-      process.stdout.write(`${c.dim}    ${(i + 1).toString().padStart(4)}  ${o}${c.reset}\n`);
-    }
-  }
-  if (maxLines > LIMIT) {
-    console.log(`${c.dim}  ... ${maxLines - LIMIT} more lines omitted${c.reset}`);
-  }
-  console.log(`${c.bold}${c.white}  └──────────────────────────────────────${c.reset}\n`);
-}
-
 async function confirm(prompt: string): Promise<boolean> {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   try {
@@ -86,35 +57,6 @@ async function readFileTool(cwd: string, args: { path: string }): Promise<string
   return fs.readFile(full, "utf-8");
 }
 
-async function writeFileTool(cwd: string, args: { path: string; content: string }): Promise<string> {
-  const full = resolveInCwd(cwd, args.path);
-  const lines = args.content.split("\n").length;
-  const bytes = Buffer.byteLength(args.content, "utf-8");
-
-  console.log(`\n${c.bold}${c.magenta}  ◆ write_file${c.reset} ${c.dim}${args.path}${c.reset}`);
-  console.log(`${c.dim}     ${lines} lines  ·  ${bytes} bytes${c.reset}`);
-
-  // Show diff vs existing file
-  let oldContent: string | null = null;
-  try {
-    oldContent = await fs.readFile(full, "utf-8");
-    console.log(`${c.dim}     (modifying existing file)${c.reset}`);
-  } catch {
-    console.log(`${c.dim}     (creating new file)${c.reset}`);
-  }
-
-  printDiff(oldContent, args.content, args.path);
-
-  const approved = await confirm(`Write ${bytes} bytes to "${args.path}"?`);
-  if (!approved) return "User declined to write this file.";
-
-  await fs.mkdir(path.dirname(full), { recursive: true });
-  await fs.writeFile(full, args.content, "utf-8");
-
-  console.log(`${c.green}${c.bold}  ✓ Wrote ${args.path}${c.reset} ${c.dim}(${bytes} bytes)${c.reset}\n`);
-  return `Wrote ${bytes} bytes to ${args.path}`;
-}
-
 async function runCommandTool(cwd: string, args: { command: string }): Promise<string> {
   console.log(`\n${c.bold}${c.yellow}  ◆ run_command${c.reset} ${c.dim}${args.command}${c.reset}`);
   const approved = await confirm(`Run: ${c.bold}${args.command}${c.reset}?`);
@@ -150,13 +92,7 @@ async function runCommandTool(cwd: string, args: { command: string }): Promise<s
 
 async function gitTool(cwd: string, args: { args: string[] }): Promise<string> {
   const cmd = `git ${args.args.join(" ")}`;
-  const isMutating = !["status", "diff", "log", "show", "branch"].includes(args.args[0]);
-
   header("git", cmd);
-  if (isMutating) {
-    const approved = await confirm(`Run: ${c.bold}${cmd}${c.reset}?`);
-    if (!approved) return "User declined to run this git command.";
-  }
 
   return new Promise((resolve) => {
     exec(cmd, { cwd, timeout: 30_000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
@@ -178,7 +114,6 @@ async function listDirectoryTool(cwd: string, args: { path: string }): Promise<s
     if (e.isSymbolicLink()) return `  ${c.cyan}${e.name}@${c.reset}`;
     return `  ${e.name}`;
   });
-  // Print inline preview
   lines.forEach(l => process.stdout.write(l + "\n"));
   return entries
     .map(e => (e.isDirectory() ? `${e.name}/` : e.name))
@@ -189,8 +124,6 @@ async function searchFilesTool(
   cwd: string,
   args: { pattern: string; glob?: string }
 ): Promise<string> {
-  // Validate inputs: pattern must be a non-empty string; glob (if provided)
-  // must only contain safe filename characters to prevent shell expansion.
   if (!args.pattern || typeof args.pattern !== "string") {
     return "Search failed: pattern must be a non-empty string.";
   }
@@ -202,7 +135,6 @@ async function searchFilesTool(
 
   header("search_files", `"${args.pattern}"${args.glob ? ` in ${args.glob}` : ""}`);
 
-  // Build the argument array passed directly to execFile — no shell involved.
   const grepArgs: string[] = [
     "-rn",
     "--color=never",
@@ -211,13 +143,11 @@ async function searchFilesTool(
   if (args.glob) {
     grepArgs.push(`--include=${args.glob}`);
   }
-  // Pattern and path as positional args (not shell-interpolated)
   grepArgs.push(args.pattern, ".");
 
   return new Promise((resolve) => {
     execFile("grep", grepArgs, { cwd, timeout: 15_000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
       if (err && (err as NodeJS.ErrnoException & { code: number }).code === 1) {
-        // grep exits 1 when no matches are found — not an error
         resolve("No matches found.");
         return;
       }
@@ -244,8 +174,6 @@ export async function executeToolCall(cwd: string, call: ToolCall): Promise<Tool
     switch (call.name) {
       case "read_file":
         return { result: await readFileTool(cwd, args), isError: false };
-      case "write_file":
-        return { result: await writeFileTool(cwd, args), isError: false };
       case "run_command":
         return { result: await runCommandTool(cwd, args), isError: false };
       case "git":