@ayoxx/kundex 0.1.7 → 1.0.0

package/src/repl.ts

@@ -1,16 +1,184 @@
 import readline from "node:readline/promises";
 import path from "node:path";
 import { execSync } from "node:child_process";
-import { Kundex, type AgentTurn } from "./sdk";
+import { Kundex, type AgentTurn, type AgentSession } from "./sdk";
 import { executeToolCall } from "./tools";
 import type { KundexConfig } from "./config";
 
-const HELP = `Commands:
-  /help    Show this help
-  /model   Show the model this session is using
-  /clear   Start a new agent session
-  /exit    Quit
-Anything else is sent to the agent as a message.`;
+// ─── ANSI colour helpers ──────────────────────────────────────────────────────
+const c = {
+  reset:   "\x1b[0m",
+  bold:    "\x1b[1m",
+  dim:     "\x1b[2m",
+  italic:  "\x1b[3m",
+  cyan:    "\x1b[36m",
+  green:   "\x1b[32m",
+  yellow:  "\x1b[33m",
+  red:     "\x1b[31m",
+  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
+};
+
+// ─── Per-language syntax highlighter (ANSI, no deps) ─────────────────────────
+interface LangRule {
+  pattern: RegExp;
+  color: string;
+}
+
+const KEYWORDS: Record<string, string[]> = {
+  python: ["def","class","return","import","from","if","elif","else","for","while",
+           "try","except","with","as","in","not","and","or","is","None","True","False","pass","raise","yield","async","await","lambda"],
+  javascript: ["const","let","var","function","return","if","else","for","while",
+               "class","extends","import","export","from","default","new","this",
+               "try","catch","finally","throw","async","await","typeof","instanceof","of","in","null","undefined","true","false"],
+  typescript: ["const","let","var","function","return","if","else","for","while",
+               "class","extends","implements","interface","type","import","export",
+               "from","default","new","this","try","catch","finally","throw","async",
+               "await","typeof","instanceof","of","in","null","undefined","true","false",
+               "string","number","boolean","any","void","never","unknown","enum","as","namespace"],
+  bash: ["if","then","else","elif","fi","for","while","do","done","case","esac",
+         "function","return","echo","exit","local","export","source","cd","ls","grep","awk","sed"],
+  go: ["func","package","import","var","const","type","struct","interface","return",
+       "if","else","for","range","switch","case","default","go","chan","defer","select","nil","true","false","map","make","new"],
+  rust: ["fn","let","mut","pub","use","mod","struct","enum","impl","trait","return",
+         "if","else","for","while","loop","match","Some","None","Ok","Err","true","false","self","Self","super","as","in","where","async","await"],
+};
+
+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"
+    : ["jsx","js","mjs"].includes(l) ? "javascript"
+    : ["python","py"].includes(l) ? "python"
+    : ["sh","shell","zsh","bash"].includes(l) ? "bash"
+    : ["rs"].includes(l) ? "rust"
+    : l;
+
+  const rules = buildRules(normalised in KEYWORDS ? normalised : "javascript");
+
+  type Span = { start: number; end: number; color: string };
+  const spans: Span[] = [];
+
+  for (const rule of rules) {
+    rule.pattern.lastIndex = 0;
+    let m: RegExpExecArray | null;
+    while ((m = rule.pattern.exec(code)) !== null) {
+      spans.push({ start: m.index, end: m.index + m[0].length, color: rule.color });
+      if (rule.pattern.lastIndex === m.index) rule.pattern.lastIndex++;
+    }
+  }
+
+  if (spans.length === 0) return code;
+
+  spans.sort((a, b) => a.start - b.start);
+  const merged: Span[] = [];
+  let cursor = 0;
+  for (const span of spans) {
+    if (span.start < cursor) continue;
+    merged.push(span);
+    cursor = span.end;
+  }
+
+  let out = "";
+  cursor = 0;
+  for (const span of merged) {
+    out += code.slice(cursor, span.start);
+    out += span.color + code.slice(span.start, span.end) + c.reset;
+    cursor = span.end;
+  }
+  out += code.slice(cursor);
+  return out;
+}
+
+// ─── Code-block printer ───────────────────────────────────────────────────────
+function printCodeBlock(lang: string, code: string) {
+  const border = "─".repeat(52);
+  const label = lang || "code";
+  const labelPad = "─".repeat(Math.max(0, 52 - label.length - 3));
+
+  process.stdout.write(`${c.dim}┌─ ${c.reset}${c.bold}${label}${c.reset}${c.dim} ${labelPad}${c.reset}\n`);
+
+  const highlighted = syntaxHighlight(code, lang);
+  highlighted.split("\n").forEach(line => {
+    process.stdout.write(`${c.dim}│${c.reset} ${line}\n`);
+  });
+
+  process.stdout.write(`${c.dim}└${border}${c.reset}\n`);
+}
+
+// ─── Reply printer (handles mixed text + code blocks) ────────────────────────
+function printReply(text: string) {
+  process.stdout.write("\n");
+  const codeBlockRe = /```(\w*)\n?([\s\S]*?)```/g;
+  let last = 0;
+  let match: RegExpExecArray | null;
+
+  while ((match = codeBlockRe.exec(text)) !== null) {
+    const before = text.slice(last, match.index);
+    if (before.trim()) {
+      before.split("\n").forEach(line => {
+        process.stdout.write(`  ${line}\n`);
+      });
+    }
+    printCodeBlock(match[1], match[2].trimEnd());
+    last = match.index + match[0].length;
+  }
+
+  const tail = text.slice(last);
+  if (tail.trim()) {
+    tail.split("\n").forEach(line => {
+      process.stdout.write(`  ${line}\n`);
+    });
+  }
+
+  process.stdout.write(`\n${c.dim}${"─".repeat(60)}${c.reset}\n\n`);
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const HELP = `
+${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.
+  • 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.
+`;
 
 function safeGitStatus(cwd: string): string | undefined {
   try {
@@ -20,78 +188,279 @@ function safeGitStatus(cwd: string): string | undefined {
   }
 }
 
+function safeFileTree(cwd: string): string | undefined {
+  try {
+    return execSync(
+      `find . -maxdepth 3 ! -path '*/node_modules/*' ! -path '*/.git/*' ! -path '*/dist/*' ! -path '*/build/*' -print`,
+      { cwd, timeout: 5000 }
+    ).toString().trim().split("\n").slice(0, 200).join("\n");
+  } catch {
+    return 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;
+  const timer = setInterval(() => {
+    process.stdout.write(`\r${c.dim}  ${frames[frame++ % frames.length]} ${label}${c.reset}  `);
+  }, 80);
+
+  return {
+    clear() {
+      clearInterval(timer);
+      process.stdout.write("\r\x1b[2K"); // CR + erase line
+    },
+  };
+}
+
+/**
+ * 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,
   sessionId: number,
   turn: AgentTurn,
+  signal?: AbortSignal,
 ): Promise<void> {
   let current = turn;
 
   while (!current.done && current.toolCalls && current.toolCalls.length > 0) {
     for (const call of current.toolCalls) {
-      console.log(`\n\u2192 ${call.name}(${call.arguments})`);
       const { result, isError } = await executeToolCall(cwd, call);
-      console.log(isError ? `  error: ${result}` : `  ${result.slice(0, 2000)}`);
+      if (isError) {
+        process.stdout.write(`${c.red}  ✗ ${call.name}: ${result}${c.reset}\n`);
+      }
 
-      current = await kundex.agent.submitToolResult({
-        sessionId,
-        toolCallId: call.id,
-        result,
-        isError,
-      });
+      // Show a spinner while waiting for the follow-up AI turn
+      const sp = createSpinner("processing tool result…");
+      let followUpText = "";
+
+      try {
+        current = await kundex.agent.submitToolResult(
+          { sessionId, toolCallId: call.id, result, isError },
+          (delta) => {
+            if (!followUpText) {
+              // First token arrived — clear the spinner
+              sp.clear();
+              process.stdout.write("\n");
+            }
+            followUpText += delta;
+            process.stdout.write(delta);
+          },
+          signal,
+        );
+      } finally {
+        sp.clear();
+      }
+
+      if (followUpText && !followUpText.endsWith("\n")) {
+        process.stdout.write("\n");
+      }
     }
   }
 
-  if (current.reply) {
-    console.log(`\nkundex: ${current.reply}\n`);
+  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);
   }
 }
 
+function printBanner(cwd: string, model: string) {
+  const shortCwd = cwd.replace(process.env.HOME ?? "", "~");
+  console.log(`
+${c.bold}${c.cyan}  ██╗  ██╗██╗   ██╗███╗   ██╗██████╗ ███████╗██╗  ██╗${c.reset}
+${c.bold}${c.cyan}  ██║ ██╔╝██║   ██║████╗  ██║██╔══██╗██╔════╝╚██╗██╔╝${c.reset}
+${c.bold}${c.cyan}  █████╔╝ ██║   ██║██╔██╗ ██║██║  ██║█████╗   ╚███╔╝ ${c.reset}
+${c.bold}${c.cyan}  ██╔═██╗ ██║   ██║██║╚██╗██║██║  ██║██╔══╝   ██╔██╗ ${c.reset}
+${c.bold}${c.cyan}  ██║  ██╗╚██████╔╝██║ ╚████║██████╔╝███████╗██╔╝ ██╗${c.reset}
+${c.bold}${c.cyan}  ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝╚═════╝ ╚══════╝╚═╝  ╚═╝${c.reset}
+
+  ${c.dim}AI coding agent — terminal edition${c.reset}
+  ${c.dim}cwd:${c.reset}   ${c.bold}${shortCwd}${c.reset}
+  ${c.dim}model:${c.reset} ${c.bold}${model}${c.reset}
+
+  Type ${c.cyan}/help${c.reset} for commands, ${c.cyan}Ctrl+C${c.reset} to stop a running request.
+`);
+}
+
+// ─── REPL ─────────────────────────────────────────────────────────────────────
 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";
 
-  console.log(`Kundex agent — cwd: ${cwd}, model: ${model}`);
-  console.log("Type /help for commands.\n");
+  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 = () => {
+    if (currentAbort && !currentAbort.signal.aborted) {
+      currentAbort.abort();
+      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);
+    }
+  };
+
+  process.on("SIGINT", sigintHandler);
+
   try {
     for (;;) {
-      const input = (await rl.question("> ")).trim();
+      const raw = await rl.question(`${c.bold}${c.cyan}kundex${c.reset} ${c.dim}▸${c.reset} `);
+      const input = raw.trim();
       if (!input) continue;
 
-      if (input === "/exit") break;
-      if (input === "/help") {
-        console.log(HELP);
-        continue;
+      // ── REPL commands ───────────────────────────────────────────────────────
+      if (input === "/exit" || input === "/quit") {
+        console.log(`\n${c.dim}Goodbye!${c.reset}\n`);
+        break;
       }
+      if (input === "/help") { console.log(HELP); continue; }
       if (input === "/model") {
-        console.log(`Model: ${session.model}`);
+        console.log(`  ${c.dim}model:${c.reset} ${c.bold}${session.model}${c.reset}`);
         continue;
       }
       if (input === "/clear") {
         session = await kundex.agent.createSession({ cwd, model });
-        console.log("Started a new session.");
+        console.log(`\n${c.green}  ✓ Started a new session.${c.reset}\n`);
         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;
+      const spinner = createSpinner("thinking…");
+      let streamedAnyText = false;
+
       try {
-        const turn = await kundex.agent.sendMessage({
-          sessionId: session.id,
-          message: input,
-          context: { gitStatus: safeGitStatus(cwd), openFiles: [] },
-        });
-        await handleTurn(kundex, cwd, session.id, turn);
+        const turn = await kundex.agent.streamMessage(
+          {
+            sessionId: session.id,
+            message: input,
+            context: {
+              gitStatus: safeGitStatus(cwd),
+              fileTree: safeFileTree(cwd),
+              openFiles: [],
+            },
+          },
+          (delta) => {
+            if (!streamedAnyText) {
+              spinner.clear();
+              process.stdout.write("\n");
+              streamedAnyText = true;
+            }
+            process.stdout.write(delta);
+          },
+          signal,
+        );
+
+        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);
+        }
       } catch (err) {
-        console.error(`Error: ${(err as Error).message}`);
+        spinner.clear();
+        const e = err as Error;
+        if (e.name === "AbortError") {
+          // Already printed "⚡ Stopped" via sigintHandler
+        } else {
+          console.error(`\n${c.red}  error: ${e.message}${c.reset}\n`);
+        }
+      } finally {
+        currentAbort = null;
       }
     }
   } finally {
+    process.off("SIGINT", sigintHandler);
     rl.close();
   }
 }