@ayoxx/kundex 0.1.9 → 1.0.0

package/package.json

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

package/src/config.ts

@@ -33,8 +33,24 @@ export function saveConfig(config: Partial<KundexConfig>): KundexConfig {
   return merged;
 }
 
-export const KUNDEX_BASE_URL = "https://kundex-api.onrender.com";
+export const KUNDEX_BASE_URL = "https://api.kundex.com.ng";
 
-export function resolveBaseUrl(_config: KundexConfig): string | null {
-  return KUNDEX_BASE_URL;
+/**
+ * Resolves the base URL to use for API calls.
+ *
+ * Priority:
+ *   1. KUNDEX_BASE_URL environment variable (useful for local dev)
+ *   2. Stored baseUrl from config (~/.kundex/config.json)
+ *   3. Hard-coded default: https://api.kundex.com.ng
+ *
+ * Previously, this function ignored the stored baseUrl completely.
+ * That made `kundex config set baseUrl <url>` a no-op, which broke
+ * local development and self-hosted deployments.
+ */
+export function resolveBaseUrl(config: KundexConfig): string | null {
+  return (
+    process.env.KUNDEX_BASE_URL?.trim() ||
+    config.baseUrl?.trim() ||
+    KUNDEX_BASE_URL
+  );
 }

package/src/index.ts

@@ -1,41 +1,575 @@
-import { loadConfig, resolveBaseUrl } from "./config";
+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";
+
+// ─── Help text ────────────────────────────────────────────────────────────────
+
+const HELP = `
+\x1b[1m\x1b[36mkundex\x1b[0m — AI coding agent CLI  v${VERSION}
+
+\x1b[1mUsage:\x1b[0m
+  kundex [command] [options]
+
+\x1b[1mAuthentication:\x1b[0m
+  login                            Save your Kundex API key
+  logout                           Remove saved credentials
+
+\x1b[1mAgent:\x1b[0m
+  (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
+
+\x1b[1mConfiguration:\x1b[0m
+  config show                      Show current configuration
+  config set <key> <val>           Set a config value
+    Keys: model, baseUrl
+
+\x1b[1mOther:\x1b[0m
+  help, --help, -h                 Show this help
+  version, --version, -v           Show version
+
+\x1b[1mExamples:\x1b[0m
+  kundex login
+  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 baseUrl https://api.kundex.com.ng
+`.trim();
+
+// ─── Colour helpers ───────────────────────────────────────────────────────────
+
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+};
+
+function ok(msg: string) { console.log(`${c.green}${c.bold}  ✓${c.reset} ${msg}`); }
+function errMsg(msg: string) { console.error(`${c.red}${c.bold}  ✗${c.reset} ${msg}`); }
+function dim(msg: string) { console.log(`${c.dim}  ${msg}${c.reset}`); }
+function header(msg: string) { console.log(`\n${c.bold}${c.cyan}  ${msg}${c.reset}`); }
+
+// ─── Commands ─────────────────────────────────────────────────────────────────
+
+const PROVIDER_DISPLAY: Record<string, string> = {
+  heavstal: "Heavstal",
+  gemini:   "Gemini",
+  groq:     "Groq",
+  mistral:  "Mistral",
+};
+
+async function cmdModels(config: ReturnType<typeof loadConfig>, baseUrl: string) {
+  const kundex = new Kundex({ apiKey: config.apiKey!, baseUrl });
+  header("Available models");
+  try {
+    const models = await kundex.models.list();
+    if (!models.length) { dim("No models found."); return; }
+    const nameWidth     = Math.max(...models.map((m) => m.name.length), 4);
+    const idWidth       = Math.max(...models.map((m) => m.id.length), 2);
+    const providerWidth = Math.max(...models.map((m) => (m.provider?.length ?? 0)), 8);
+    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) {
+      const p = m.provider ?? "other";
+      if (!grouped[p]) { grouped[p] = []; order.push(p); }
+      grouped[p].push(m);
+    }
+
+    for (const provider of order) {
+      for (const m of grouped[provider]) {
+        const ctx = m.contextWindow >= 1_000_000
+          ? `${(m.contextWindow / 1_000_000).toFixed(1)}M`
+          : m.contextWindow >= 1000
+            ? `${(m.contextWindow / 1000).toFixed(0)}k`
+            : String(m.contextWindow);
+        const providerLabel = (PROVIDER_DISPLAY[m.provider ?? ""] ?? m.provider ?? "").padEnd(providerWidth);
+        console.log(
+          `  ${c.bold}${m.name.padEnd(nameWidth)}${c.reset}` +
+          `  ${c.dim}${m.id.padEnd(idWidth)}${c.reset}` +
+          `  ${c.cyan}${providerLabel}${c.reset}` +
+          `  ${c.dim}${ctx}${c.reset}`,
+        );
+      }
+    }
+    console.log();
+  } catch (e) {
+    errMsg(`Failed to list models: ${(e as Error).message}`);
+    process.exitCode = 1;
+  }
+}
+
+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(
+  config: ReturnType<typeof loadConfig>,
+  baseUrl: string,
+  message: string,
+  args: string[],
+) {
+  if (!message) {
+    errMsg("Usage: kundex run <message>");
+    process.exitCode = 1;
+    return;
+  }
+
+  // Parse optional flags: --model, --workspace, --cwd
+  let model = config.defaultModel ?? "openai/gpt-oss-120b";
+  let wsId: number | null = null;
+  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;
+    }
+
+    process.stdout.write(`\n`);
+    const { executeToolCall } = await import("./tools");
+
+    let turn = await kundex.agent.streamMessage(
+      { sessionId, message },
+      (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);
+        turn = await kundex.agent.submitToolResult(
+          { sessionId, toolCallId: call.id, result, isError },
+          (delta) => process.stdout.write(delta),
+        );
+      }
+    }
+
+    process.stdout.write("\n");
+  } catch (e) {
+    errMsg(`Agent error: ${(e as Error).message}`);
+    process.exitCode = 1;
+  }
+}
+
+// ─── Config commands ──────────────────────────────────────────────────────────
+
+function cmdConfigShow(config: ReturnType<typeof loadConfig>, baseUrl: string) {
+  header("Current configuration");
+  console.log();
+  const rows = [
+    ["API key",  config.apiKey ? `${config.apiKey.slice(0, 8)}…` : "(not set)"],
+    ["Base URL", baseUrl],
+    ["Model",    config.defaultModel ?? "(default)"],
+  ];
+  for (const [k, v] of rows) {
+    console.log(`  ${c.dim}${k.padEnd(12)}${c.reset}  ${c.bold}${v}${c.reset}`);
+  }
+  console.log();
+}
+
+function cmdConfigSet(key: string, value: string) {
+  const allowed = ["model", "baseUrl"];
+  if (!allowed.includes(key)) {
+    errMsg(`Unknown config key "${key}". Allowed keys: ${allowed.join(", ")}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const map: Record<string, keyof ReturnType<typeof loadConfig>> = {
+    model: "defaultModel",
+    baseUrl: "baseUrl",
+  };
+
+  saveConfig({ [map[key]]: value });
+  ok(`Set ${key} = ${value}`);
+}
+
+function cmdLogout() {
+  saveConfig({ apiKey: null, baseUrl: null, defaultModel: null });
+  ok("Logged out. Run `kundex login` to authenticate again.");
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
 
 async function main(): Promise<void> {
-  const [, , command] = process.argv;
+  const args = process.argv.slice(2);
+  const [command, sub, ...rest] = args;
 
-  if (command === "login") {
-    await runLogin();
+  // Version
+  if (command === "version" || command === "--version" || command === "-v") {
+    console.log(`kundex v${VERSION}`);
     return;
   }
 
+  // Help
   if (command === "help" || command === "--help" || command === "-h") {
-    console.log(
-      [
-        "kundeX — terminal AI coding agent.",
-        "",
-        "Usage:",
-        "  kundex login   Save your API key and API base URL",
-        "  kundex         Start the agent REPL in the current directory",
-      ].join("\n"),
-    );
+    console.log(HELP);
+    return;
+  }
+
+  // No command — drop into REPL if logged in, else show help
+  if (!command) {
+    const config = loadConfig();
+    const baseUrl = resolveBaseUrl(config);
+    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;
+  }
+
+  // Login / logout
+  if (command === "login") {
+    await runLogin();
+    return;
+  }
+  if (command === "logout") {
+    cmdLogout();
     return;
   }
 
+  // Load config — required for all remaining commands
   const config = loadConfig();
   const baseUrl = resolveBaseUrl(config);
 
   if (!config.apiKey || !baseUrl) {
-    console.error('Not logged in. Run "kundex login" first.');
+    errMsg('Not logged in. Run "kundex login" first.');
     process.exitCode = 1;
     return;
   }
 
-  await runRepl(config, config.apiKey, baseUrl);
+  // Models
+  if (command === "models") {
+    await cmdModels(config, baseUrl);
+    return;
+  }
+
+  // Config
+  if (command === "config") {
+    if (sub === "show" || !sub) {
+      cmdConfigShow(config, baseUrl);
+    } else if (sub === "set") {
+      const [key, value] = rest;
+      if (!key || !value) {
+        errMsg("Usage: kundex config set <key> <value>");
+        process.exitCode = 1;
+      } else {
+        cmdConfigSet(key, value);
+      }
+    } else {
+      errMsg(`Unknown config subcommand "${sub}". Use: show, set`);
+      process.exitCode = 1;
+    }
+    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);
+    return;
+  }
+
+  // Unknown command — suggest help
+  errMsg(`Unknown command "${command}". Run \`kundex help\` to see available commands.`);
+  process.exitCode = 1;
 }
 
-main().catch((err) => {
-  console.error(err instanceof Error ? err.message : err);
+main().catch((e) => {
+  console.error(`${c.red}  Fatal: ${e instanceof Error ? e.message : e}${c.reset}`);
   process.exitCode = 1;
 });

package/src/repl.ts

@@ -1,7 +1,7 @@
 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";
 
@@ -73,16 +73,16 @@ function buildRules(lang: string): LangRule[] {
 
 /** Apply regex-based ANSI syntax highlighting to a code string. */
 function syntaxHighlight(code: string, lang: string): string {
-  const l = lang.toLowerCase().replace(/^(tsx?|jsx?)$/, lang.includes("ts") || lang.includes("tsx") ? "typescript" : "javascript");
-  const normalised = ["python","py"].includes(l) ? "python"
-    : ["sh","shell","zsh"].includes(l) ? "bash"
+  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");
 
-  // We work character-by-character with a simple placeholder approach:
-  // collect all matches with their positions, sort them, then reconstruct.
   type Span = { start: number; end: number; color: string };
   const spans: Span[] = [];
 
@@ -97,7 +97,6 @@ function syntaxHighlight(code: string, lang: string): string {
 
   if (spans.length === 0) return code;
 
-  // Sort by start; discard overlapping spans (first wins)
   spans.sort((a, b) => a.start - b.start);
   const merged: Span[] = [];
   let cursor = 0;
@@ -144,7 +143,6 @@ function printReply(text: string) {
   while ((match = codeBlockRe.exec(text)) !== null) {
     const before = text.slice(last, match.index);
     if (before.trim()) {
-      // Wrap plain text at ~100 chars
       before.split("\n").forEach(line => {
         process.stdout.write(`  ${line}\n`);
       });
@@ -166,15 +164,20 @@ function printReply(text: string) {
 // ─── 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
-  /exit         Quit kundex
+  /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 {
@@ -196,11 +199,35 @@ 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;
+  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;
 
@@ -210,16 +237,39 @@ async function handleTurn(
       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) {
+  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);
   }
 }
@@ -238,7 +288,7 @@ ${c.bold}${c.cyan}  ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═
   ${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.
+  Type ${c.cyan}/help${c.reset} for commands, ${c.cyan}Ctrl+C${c.reset} to stop a running request.
 `);
 }
 
@@ -253,13 +303,33 @@ export async function runRepl(config: KundexConfig, apiKey: string, baseUrl: str
   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 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") {
+      // ── REPL commands ───────────────────────────────────────────────────────
+      if (input === "/exit" || input === "/quit") {
         console.log(`\n${c.dim}Goodbye!${c.reset}\n`);
         break;
       }
@@ -274,23 +344,123 @@ 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;
+      const spinner = createSpinner("thinking…");
+      let streamedAnyText = false;
+
       try {
-        process.stdout.write(`\n${c.dim}  thinking...${c.reset}\n`);
-        const turn = await kundex.agent.sendMessage({
-          sessionId: session.id,
-          message: input,
-          context: {
-            gitStatus: safeGitStatus(cwd),
-            fileTree: safeFileTree(cwd),
-            openFiles: [],
+        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);
           },
-        });
-        await handleTurn(kundex, cwd, session.id, turn);
+          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(`\n${c.red}  error: ${(err as Error).message}${c.reset}\n`);
+        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();
   }
 }

package/src/sdk.ts

@@ -21,6 +21,8 @@ export interface ChatUsage {
 export interface ModelInfo {
   id: string;
   name: string;
+  /** Which inference provider serves this model (e.g. "heavstal", "groq", "gemini", "mistral"). */
+  provider?: string;
   contextWindow: number;
   inputPricePerMTok: number;
   outputPricePerMTok: number;
@@ -34,6 +36,33 @@ export interface AgentTurn {
   usage: ChatUsage | null;
 }
 
+export interface AgentSession {
+  id: number;
+  cwd: string;
+  model: string;
+  name: string;
+  description: string;
+  language: string;
+  wsStatus: string;
+  pinned: boolean;
+  lastOpenedAt: string | null;
+  lastModifiedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface WorkspaceFile {
+  id: number;
+  sessionId: number;
+  path: string;
+  name: string;
+  mimeType: string;
+  size: number;
+  content?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
 export interface KundexOptions {
   apiKey: string;
   baseUrl: string;
@@ -49,7 +78,7 @@ export interface KundexOptions {
  */
 export class Kundex {
   private apiKey: string;
-  private baseUrl: string;
+  readonly baseUrl: string;
 
   constructor(opts: KundexOptions) {
     if (!opts.apiKey) throw new Error("Kundex: apiKey is required");
@@ -76,9 +105,37 @@ export class Kundex {
     return (await res.json()) as T;
   }
 
+  private async requestGet<T>(pathname: string): Promise<T> {
+    const res = await fetch(`${this.baseUrl}${pathname}`, {
+      method: "GET",
+      headers: { authorization: `Bearer ${this.apiKey}` },
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Kundex API error (${res.status}): ${text || res.statusText}`);
+    }
+
+    return (await res.json()) as T;
+  }
+
+  private async requestDelete(pathname: string): Promise<void> {
+    const res = await fetch(`${this.baseUrl}${pathname}`, {
+      method: "DELETE",
+      headers: { authorization: `Bearer ${this.apiKey}` },
+    });
+
+    if (!res.ok && res.status !== 204) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Kundex API error (${res.status}): ${text || res.statusText}`);
+    }
+  }
+
   models = {
     list: async (): Promise<ModelInfo[]> => {
-      const res = await fetch(`${this.baseUrl}/v1/models`);
+      const res = await fetch(`${this.baseUrl}/v1/models`, {
+        headers: { authorization: `Bearer ${this.apiKey}` },
+      });
       if (!res.ok) throw new Error(`Kundex API error (${res.status})`);
       return (await res.json()) as ModelInfo[];
     },
@@ -109,6 +166,7 @@ export class Kundex {
         tools?: KundexToolDefinition[];
       },
       onDelta: (text: string) => void,
+      signal?: AbortSignal,
     ): Promise<{ finishReason: string; usage: ChatUsage | null }> => {
       const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
         method: "POST",
@@ -117,6 +175,7 @@ export class Kundex {
           authorization: `Bearer ${this.apiKey}`,
         },
         body: JSON.stringify({ ...params, stream: true }),
+        signal,
       });
 
       if (!res.ok || !res.body) {
@@ -130,25 +189,32 @@ export class Kundex {
       let finishReason = "stop";
       let usage: ChatUsage | null = null;
 
-      for (;;) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed.startsWith("data:")) continue;
-          const payload = trimmed.slice(5).trim();
-          if (!payload) continue;
-          const json = JSON.parse(payload);
-          if (json.delta) onDelta(json.delta);
-          if (json.done) {
-            finishReason = json.finishReason ?? finishReason;
-            usage = json.usage ?? usage;
+      try {
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith(":")) continue; // heartbeat comment
+            if (!trimmed.startsWith("data:")) continue;
+            const payload = trimmed.slice(5).trim();
+            if (!payload || payload === "[DONE]") continue;
+            try {
+              const json = JSON.parse(payload);
+              if (json.delta) onDelta(json.delta);
+              if (json.done) {
+                finishReason = json.finishReason ?? finishReason;
+                usage = json.usage ?? usage;
+              }
+            } catch { /* ignore bad JSON */ }
           }
         }
+      } finally {
+        try { reader.cancel(); } catch { /* ignore */ }
       }
 
       return { finishReason, usage };
@@ -156,23 +222,242 @@ export class Kundex {
   };
 
   agent = {
-    createSession: (params: { cwd: string; model?: string }) =>
-      this.request<{ id: number; cwd: string; model: string; createdAt: string }>(
-        "/v1/agent/session",
-        params,
+    createSession: (params: {
+      cwd: string;
+      model?: string;
+      name?: string;
+      description?: string;
+      language?: string;
+    }) =>
+      this.request<AgentSession>("/v1/agent/session", params),
+
+    listSessions: () =>
+      this.requestGet<AgentSession[]>("/v1/agent/sessions"),
+
+    getSession: (id: number) =>
+      this.requestGet<AgentSession>(`/v1/agent/sessions/${id}`),
+
+    deleteSession: (id: number) =>
+      this.requestDelete(`/v1/agent/sessions/${id}`),
+
+    getMessages: (id: number) =>
+      this.requestGet<{ sessionId: number; messages: unknown[] }>(`/v1/agent/sessions/${id}/messages`),
+
+    /**
+     * Send a message to the agent and stream the response.
+     *
+     * The server sends SSE events — this method handles the typed format
+     * emitted by the backend:
+     *   { type: "delta",  delta: string }
+     *   { type: "done",   reply?, toolCalls?, done, usage? }
+     *   { type: "error",  error: string }
+     *
+     * Invokes onDelta as text tokens arrive so the caller can print them
+     * incrementally.
+     *
+     * Returns the completed AgentTurn including any tool calls.
+     */
+    streamMessage: async (
+      params: {
+        sessionId: number;
+        message: string;
+        context?: { fileTree?: string; gitStatus?: string; openFiles?: string[] };
+      },
+      onDelta: (text: string) => void,
+      signal?: AbortSignal,
+    ): Promise<AgentTurn> => {
+      const endpoint = "/v1/agent/message";
+      const res = await fetch(`${this.baseUrl}${endpoint}`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify(params),
+        signal,
+      });
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`Kundex API error (${res.status}): ${text || res.statusText}`);
+      }
+
+      const reader = res.body?.getReader();
+      if (!reader) throw new Error("No response body from server");
+
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let reply = "";
+      let toolCalls: AgentTurn["toolCalls"] = null;
+      let usage: AgentTurn["usage"] = null;
+
+      try {
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith(":")) continue; // heartbeat comment
+            if (!trimmed.startsWith("data:")) continue;
+            const payload = trimmed.slice(5).trim();
+            if (!payload || payload === "[DONE]") continue;
+
+            try {
+              const ev = JSON.parse(payload);
+
+              if (ev.type === "delta" && typeof ev.delta === "string") {
+                reply += ev.delta;
+                onDelta(ev.delta);
+                continue;
+              }
+              if (ev.type === "done") {
+                return {
+                  sessionId: params.sessionId,
+                  reply: ev.reply !== undefined ? (ev.reply ?? reply) : reply,
+                  toolCalls: ev.toolCalls ?? ev.tool_calls ?? null,
+                  done: ev.done ?? true,
+                  usage: ev.usage ?? usage,
+                };
+              }
+              if (ev.type === "error") {
+                throw new Error(ev.error ?? "Agent error");
+              }
+
+              // Legacy format fallback
+              if (typeof ev.delta === "string") {
+                reply += ev.delta;
+                onDelta(ev.delta);
+              }
+              if (ev.done === true) {
+                return {
+                  sessionId: params.sessionId,
+                  reply: ev.reply ?? reply,
+                  toolCalls: ev.tool_calls ?? ev.toolCalls ?? null,
+                  done: true,
+                  usage: ev.usage ?? usage,
+                };
+              }
+            } catch (parseErr) {
+              if (parseErr instanceof SyntaxError) continue;
+              throw parseErr;
+            }
+          }
+        }
+      } finally {
+        try { reader.cancel(); } catch { /* ignore */ }
+      }
+
+      // Stream ended without a done event; return what we have
+      return { sessionId: params.sessionId, reply, toolCalls, done: true, usage };
+    },
+
+    submitToolResult: async (
+      params: {
+        sessionId: number;
+        toolCallId: string;
+        result: string;
+        isError?: boolean;
+      },
+      onDelta: (text: string) => void,
+      signal?: AbortSignal,
+    ): Promise<AgentTurn> => {
+      const res = await fetch(`${this.baseUrl}/v1/agent/tool-result`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify(params),
+        signal,
+      });
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`Kundex API error (${res.status}): ${text || res.statusText}`);
+      }
+
+      const reader = res.body?.getReader();
+      if (!reader) throw new Error("No response body from server");
+
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let reply = "";
+      let toolCalls: AgentTurn["toolCalls"] = null;
+      let usage: AgentTurn["usage"] = null;
+
+      try {
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith(":")) continue;
+            if (!trimmed.startsWith("data:")) continue;
+            const payload = trimmed.slice(5).trim();
+            if (!payload || payload === "[DONE]") continue;
+
+            try {
+              const ev = JSON.parse(payload);
+              if (ev.type === "delta" && typeof ev.delta === "string") {
+                reply += ev.delta;
+                onDelta(ev.delta);
+                continue;
+              }
+              if (ev.type === "done") {
+                return {
+                  sessionId: params.sessionId,
+                  reply: ev.reply !== undefined ? (ev.reply ?? reply) : reply,
+                  toolCalls: ev.toolCalls ?? ev.tool_calls ?? null,
+                  done: ev.done ?? true,
+                  usage: ev.usage ?? usage,
+                };
+              }
+              if (ev.type === "error") throw new Error(ev.error ?? "Agent error");
+              if (typeof ev.delta === "string") { reply += ev.delta; onDelta(ev.delta); }
+              if (ev.done === true) {
+                return {
+                  sessionId: params.sessionId,
+                  reply: ev.reply ?? reply,
+                  toolCalls: ev.tool_calls ?? ev.toolCalls ?? null,
+                  done: true,
+                  usage: ev.usage ?? usage,
+                };
+              }
+            } catch (parseErr) {
+              if (parseErr instanceof SyntaxError) continue;
+              throw parseErr;
+            }
+          }
+        }
+      } finally {
+        try { reader.cancel(); } catch { /* ignore */ }
+      }
+
+      return { sessionId: params.sessionId, reply, toolCalls, done: true, usage };
+    },
+  };
+
+  files = {
+    list: (wsId: number) =>
+      this.requestGet<{ files: WorkspaceFile[] }>(`/v1/workspace/${wsId}/files`),
+
+    get: (wsId: number, path: string) =>
+      this.requestGet<WorkspaceFile>(
+        `/v1/workspace/${wsId}/files/content?path=${encodeURIComponent(path)}`,
       ),
 
-    sendMessage: (params: {
-      sessionId: number;
-      message: string;
-      context?: { fileTree?: string; gitStatus?: string; openFiles?: string[] };
-    }) => this.request<AgentTurn>("/v1/agent/message", params),
-
-    submitToolResult: (params: {
-      sessionId: number;
-      toolCallId: string;
-      result: string;
-      isError?: boolean;
-    }) => this.request<AgentTurn>("/v1/agent/tool-result", params),
+    upsert: (wsId: number, params: { path: string; name: string; content: string; mimeType?: string }) =>
+      this.request<{ file: WorkspaceFile }>(`/v1/workspace/${wsId}/files`, params),
+
+    delete: (wsId: number, path: string) =>
+      this.requestDelete(`/v1/workspace/${wsId}/files?path=${encodeURIComponent(path)}`),
   };
 }