@ayoxx/kundex 2.0.4 → 2.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ayoxx/kundex",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "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.4";
+const VERSION = "2.0.6";
 
 // ─── Help text ────────────────────────────────────────────────────────────────
 

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,8 +362,11 @@ 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();

package/src/sdk.ts

@@ -133,7 +133,7 @@ export class Kundex {
 
   models = {
     list: async (): Promise<ModelInfo[]> => {
-      const res = await fetch(`${this.baseUrl}/v1/models`, {
+      const res = await fetch(`${this.baseUrl}/api/v1/models`, {
         headers: { authorization: `Bearer ${this.apiKey}` },
       });
       if (!res.ok) throw new Error(`Kundex API error (${res.status})`);
@@ -155,7 +155,7 @@ export class Kundex {
         message: KundexChatMessage;
         finishReason: string;
         usage: ChatUsage;
-      }>("/v1/chat/completions", { ...params, stream: false }),
+      }>("/api/v1/chat/completions", { ...params, stream: false }),
 
     /** Streaming chat completion; invokes onDelta as tokens arrive. */
     stream: async (
@@ -168,7 +168,7 @@ export class Kundex {
       onDelta: (text: string) => void,
       signal?: AbortSignal,
     ): Promise<{ finishReason: string; usage: ChatUsage | null }> => {
-      const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+      const res = await fetch(`${this.baseUrl}/api/v1/chat/completions`, {
         method: "POST",
         headers: {
           "content-type": "application/json",
@@ -229,19 +229,19 @@ export class Kundex {
       description?: string;
       language?: string;
     }) =>
-      this.request<AgentSession>("/v1/agent/session", params),
+      this.request<AgentSession>("/api/v1/agent/session", params),
 
     listSessions: () =>
-      this.requestGet<AgentSession[]>("/v1/agent/sessions"),
+      this.requestGet<AgentSession[]>("/api/v1/agent/sessions"),
 
     getSession: (id: number) =>
-      this.requestGet<AgentSession>(`/v1/agent/sessions/${id}`),
+      this.requestGet<AgentSession>(`/api/v1/agent/sessions/${id}`),
 
     deleteSession: (id: number) =>
-      this.requestDelete(`/v1/agent/sessions/${id}`),
+      this.requestDelete(`/api/v1/agent/sessions/${id}`),
 
     getMessages: (id: number) =>
-      this.requestGet<{ sessionId: number; messages: unknown[] }>(`/v1/agent/sessions/${id}/messages`),
+      this.requestGet<{ sessionId: number; messages: unknown[] }>(`/api/v1/agent/sessions/${id}/messages`),
 
     /**
      * Send a message to the agent and stream the response.
@@ -266,7 +266,7 @@ export class Kundex {
       onDelta: (text: string) => void,
       signal?: AbortSignal,
     ): Promise<AgentTurn> => {
-      const endpoint = "/v1/agent/message";
+      const endpoint = "/api/v1/agent/message";
       const res = await fetch(`${this.baseUrl}${endpoint}`, {
         method: "POST",
         headers: {
@@ -365,7 +365,7 @@ export class Kundex {
       onDelta: (text: string) => void,
       signal?: AbortSignal,
     ): Promise<AgentTurn> => {
-      const res = await fetch(`${this.baseUrl}/v1/agent/tool-result`, {
+      const res = await fetch(`${this.baseUrl}/api/v1/agent/tool-result`, {
         method: "POST",
         headers: {
           "content-type": "application/json",
@@ -447,17 +447,17 @@ export class Kundex {
 
   files = {
     list: (wsId: number) =>
-      this.requestGet<{ files: WorkspaceFile[] }>(`/v1/workspace/${wsId}/files`),
+      this.requestGet<{ files: WorkspaceFile[] }>(`/api/v1/workspace/${wsId}/files`),
 
     get: (wsId: number, path: string) =>
       this.requestGet<WorkspaceFile>(
-        `/v1/workspace/${wsId}/files/content?path=${encodeURIComponent(path)}`,
+        `/api/v1/workspace/${wsId}/files/content?path=${encodeURIComponent(path)}`,
       ),
 
     upsert: (wsId: number, params: { path: string; name: string; content: string; mimeType?: string }) =>
-      this.request<{ file: WorkspaceFile }>(`/v1/workspace/${wsId}/files`, params),
+      this.request<{ file: WorkspaceFile }>(`/api/v1/workspace/${wsId}/files`, params),
 
     delete: (wsId: number, path: string) =>
-      this.requestDelete(`/v1/workspace/${wsId}/files?path=${encodeURIComponent(path)}`),
+      this.requestDelete(`/api/v1/workspace/${wsId}/files?path=${encodeURIComponent(path)}`),
   };
 }

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 };
     }