@ayoxx/kundex 2.0.5 → 2.0.7

package/package.json

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

package/src/index.ts

@@ -3,7 +3,7 @@ import { runLogin } from "./login";
 import { runRepl } from "./repl";
 import { Kundex } from "./sdk";
 
-const VERSION = "2.0.5";
+const VERSION = "2.0.7";
 
 // ─── Help text ────────────────────────────────────────────────────────────────
 
@@ -335,6 +335,13 @@ async function main(): Promise<void> {
 }
 
 main().catch((e) => {
-  console.error(`${c.red}  Fatal: ${e instanceof Error ? e.message : e}${c.reset}`);
+  const msg = e instanceof Error ? e.message : String(e);
+  if (msg.includes("fetch failed") || msg.includes("ECONNREFUSED") || msg.includes("ENOTFOUND")) {
+    console.error(`\n${c.red}  ✗ Could not connect to the API server.${c.reset}`);
+    console.error(`${c.dim}  Check your internet connection and try again.${c.reset}`);
+    console.error(`${c.dim}  Run "kundex login" if you haven't set up your API key.${c.reset}\n`);
+  } else {
+    console.error(`\n${c.red}  ✗ ${msg}${c.reset}\n`);
+  }
   process.exitCode = 1;
 });

package/src/repl.ts

@@ -161,11 +161,19 @@ ${c.bold}Commands:${c.reset}
   /clear              Start a fresh agent session
   /exit               Quit kundex
 
+${c.bold}Capabilities:${c.reset}
+  • Read, write, edit, and create files
+  • Run shell commands (npm, git, python, make, etc.)
+  • Search through codebases
+  • Search the web for documentation and solutions
+  • Fetch and read web pages
+  • Initialize git repos and make commits
+  • Install packages and dependencies
+
 ${c.bold}Tips:${c.reset}
-  • 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.
+  • Code blocks are syntax-highlighted automatically.
+  • The agent will ask for confirmation before writes and shell commands.
+  • Responses stream in real-time.
   • Press Ctrl+C to abort a running request.
 `;
 
@@ -245,10 +253,13 @@ async function handleTurn(
     }
   }
 
-  if (current.reply && !turn.toolCalls?.length) {
+  if (current.reply && current.reply.trim() && !turn.toolCalls?.length) {
     process.stdout.write(`\n${c.dim}${"─".repeat(60)}${c.reset}\n\n`);
-  } else if (current.reply) {
+  } else if (current.reply && current.reply.trim()) {
     printReply(current.reply);
+  } else if (turn.toolCalls?.length) {
+    // After tool calls, if no text was returned, just print the separator
+    process.stdout.write(`\n${c.dim}${"─".repeat(60)}${c.reset}\n\n`);
   }
 }
 
@@ -351,14 +362,20 @@ export async function runRepl(config: KundexConfig, apiKey: string, baseUrl: str
           await handleTurn(kundex, cwd, session.id, turn, signal);
         } else if (streamedAnyText) {
           process.stdout.write(`\n${c.dim}${"─".repeat(60)}${c.reset}\n\n`);
-        } else if (turn.reply) {
+        } else if (turn.reply && turn.reply.trim()) {
           printReply(turn.reply);
+        } else {
+          // Empty response — show a message so user knows something happened
+          process.stdout.write(`\n${c.dim}  (no response — try rephrasing your message)${c.reset}\n\n`);
         }
       } catch (err) {
         spinner.clear();
         const e = err as Error;
         if (e.name === "AbortError") {
           // Already printed "⚡ Stopped" via sigintHandler
+        } else if (e.message.includes("fetch failed") || e.message.includes("ECONNREFUSED")) {
+          console.error(`\n${c.red}  ✗ Could not connect to the API server.${c.reset}`);
+          console.error(`${c.dim}  Check your internet connection and try again.${c.reset}\n`);
         } else {
           console.error(`\n${c.red}  error: ${e.message}${c.reset}\n`);
         }

package/src/tools.ts

@@ -33,6 +33,34 @@ 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 = 40;
+  const shown = Math.min(maxLines, LIMIT);
+
+  console.log(`${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 {
@@ -51,19 +79,108 @@ function resolveInCwd(cwd: string, relPath: string): string {
   return resolved;
 }
 
+// ── File tools ────────────────────────────────────────────────────────────────
+
 async function readFileTool(cwd: string, args: { path: string }): Promise<string> {
   const full = resolveInCwd(cwd, args.path);
   header("read_file", args.path);
   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}`);
+
+  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 appendToFileTool(cwd: string, args: { path: string; content: string }): Promise<string> {
+  const full = resolveInCwd(cwd, args.path);
+  const bytes = Buffer.byteLength(args.content, "utf-8");
+
+  header("append_to_file", args.path);
+
+  const approved = await confirm(`Append ${bytes} bytes to "${args.path}"?`);
+  if (!approved) return "User declined to append to this file.";
+
+  await fs.mkdir(path.dirname(full), { recursive: true });
+  await fs.appendFile(full, args.content, "utf-8");
+
+  console.log(`${c.green}${c.bold}  ✓ Appended to ${args.path}${c.reset}\n`);
+  return `Appended ${bytes} bytes to ${args.path}`;
+}
+
+async function renameFileTool(cwd: string, args: { old_path: string; new_path: string }): Promise<string> {
+  const oldFull = resolveInCwd(cwd, args.old_path);
+  const newFull = resolveInCwd(cwd, args.new_path);
+
+  header("rename_file", `${args.old_path} → ${args.new_path}`);
+
+  const approved = await confirm(`Rename "${args.old_path}" to "${args.new_path}"?`);
+  if (!approved) return "User declined to rename.";
+
+  await fs.mkdir(path.dirname(newFull), { recursive: true });
+  await fs.rename(oldFull, newFull);
+
+  console.log(`${c.green}${c.bold}  ✓ Renamed${c.reset}\n`);
+  return `Renamed ${args.old_path} to ${args.new_path}`;
+}
+
+async function deleteFileTool(cwd: string, args: { path: string }): Promise<string> {
+  const full = resolveInCwd(cwd, args.path);
+
+  header("delete_file", args.path);
+
+  const approved = await confirm(`Permanently delete "${args.path}"?`);
+  if (!approved) return "User declined to delete.";
+
+  await fs.unlink(full);
+
+  console.log(`${c.green}${c.bold}  ✓ Deleted ${args.path}${c.reset}\n`);
+  return `Deleted ${args.path}`;
+}
+
+async function createDirectoryTool(cwd: string, args: { path: string }): Promise<string> {
+  const full = resolveInCwd(cwd, args.path);
+
+  header("create_directory", args.path);
+
+  await fs.mkdir(full, { recursive: true });
+
+  console.log(`${c.green}${c.bold}  ✓ Created directory ${args.path}${c.reset}\n`);
+  return `Created directory ${args.path}`;
+}
+
+// ── Shell tools ───────────────────────────────────────────────────────────────
+
 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}?`);
   if (!approved) return "User declined to run this command.";
 
   return new Promise((resolve) => {
-    const child = exec(args.command, { cwd, timeout: 60_000, maxBuffer: 4 * 1024 * 1024 });
+    const child = exec(args.command, { cwd, timeout: 120_000, maxBuffer: 4 * 1024 * 1024 });
 
     let stdout = "";
     let stderr = "";
@@ -92,7 +209,13 @@ 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) => {
@@ -138,7 +261,7 @@ async function searchFilesTool(
   const grepArgs: string[] = [
     "-rn",
     "--color=never",
-    "-m", "5",
+    "-m", "10",
   ];
   if (args.glob) {
     grepArgs.push(`--include=${args.glob}`);
@@ -162,6 +285,91 @@ async function searchFilesTool(
   });
 }
 
+// ── Web tools ─────────────────────────────────────────────────────────────────
+
+async function webSearchTool(_cwd: string, args: { query: string }): Promise<string> {
+  header("web_search", args.query);
+
+  try {
+    // Use DuckDuckGo instant answer API
+    const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(args.query)}&format=json&no_html=1&skip_disambig=1`;
+    const res = await fetch(url, {
+      headers: { "User-Agent": "Kundex/2.0.6" },
+      signal: AbortSignal.timeout(10_000),
+    });
+    const data = await res.json() as any;
+
+    const results: string[] = [];
+
+    if (data.AbstractText) {
+      results.push(`**${data.Heading || args.query}**\n${data.AbstractText}`);
+      if (data.AbstractURL) results.push(`Source: ${data.AbstractURL}`);
+    }
+
+    if (data.Answer) {
+      results.push(`Answer: ${data.Answer}`);
+    }
+
+    if (data.RelatedTopics?.length) {
+      const topics = data.RelatedTopics
+        .filter((t: any) => t.Text)
+        .slice(0, 5)
+        .map((t: any) => `- ${t.Text}${t.FirstURL ? ` (${t.FirstURL})` : ""}`);
+      if (topics.length) {
+        results.push("Related:\n" + topics.join("\n"));
+      }
+    }
+
+    if (results.length === 0) {
+      // Fallback: return a helpful message
+      return `No instant answer found for "${args.query}". Try using fetch_url to read a specific documentation page, or rephrase your search.`;
+    }
+
+    return results.join("\n\n");
+  } catch (err) {
+    return `Web search failed: ${(err as Error).message}`;
+  }
+}
+
+async function fetchUrlTool(_cwd: string, args: { url: string }): Promise<string> {
+  header("fetch_url", args.url);
+
+  try {
+    const res = await fetch(args.url, {
+      headers: {
+        "User-Agent": "Kundex/2.0.6",
+        "Accept": "text/html,application/xhtml+xml,text/plain",
+      },
+      signal: AbortSignal.timeout(15_000),
+      redirect: "follow",
+    });
+
+    if (!res.ok) {
+      return `HTTP ${res.status} ${res.statusText}`;
+    }
+
+    const contentType = res.headers.get("content-type") ?? "";
+    const text = await res.text();
+
+    if (contentType.includes("text/html")) {
+      // Strip HTML tags for readability
+      const stripped = text
+        .replace(/<script[\s\S]*?<\/script>/gi, "")
+        .replace(/<style[\s\S]*?<\/style>/gi, "")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+      return stripped.slice(0, 8000);
+    }
+
+    return text.slice(0, 8000);
+  } catch (err) {
+    return `Fetch failed: ${(err as Error).message}`;
+  }
+}
+
+// ── Main dispatcher ───────────────────────────────────────────────────────────
+
 export async function executeToolCall(cwd: string, call: ToolCall): Promise<ToolResult> {
   let args: any;
   try {
@@ -174,6 +382,16 @@ 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 "append_to_file":
+        return { result: await appendToFileTool(cwd, args), isError: false };
+      case "rename_file":
+        return { result: await renameFileTool(cwd, args), isError: false };
+      case "delete_file":
+        return { result: await deleteFileTool(cwd, args), isError: false };
+      case "create_directory":
+        return { result: await createDirectoryTool(cwd, args), isError: false };
       case "run_command":
         return { result: await runCommandTool(cwd, args), isError: false };
       case "git":
@@ -182,6 +400,10 @@ export async function executeToolCall(cwd: string, call: ToolCall): Promise<Tool
         return { result: await listDirectoryTool(cwd, args), isError: false };
       case "search_files":
         return { result: await searchFilesTool(cwd, args), isError: false };
+      case "web_search":
+        return { result: await webSearchTool(cwd, args), isError: false };
+      case "fetch_url":
+        return { result: await fetchUrlTool(cwd, args), isError: false };
       default:
         return { result: `Unknown tool: ${call.name}`, isError: true };
     }