@jc20231028/local-code-agent 0.1.0

package/src/syntaxCheck.js

@@ -0,0 +1,62 @@
+import path from "node:path";
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFile = promisify(execFileCallback);
+const CHECK_TIMEOUT_MS = 5000;
+const PYTHON_CANDIDATES = ["python", "python3", "py"];
+
+export async function checkSyntax(fullPath) {
+  const extension = path.extname(fullPath).toLowerCase();
+
+  if (extension === ".py") {
+    return checkWithPython(fullPath);
+  }
+
+  if (extension === ".js" || extension === ".mjs") {
+    return checkWithNode(fullPath);
+  }
+
+  return { checked: false, ok: true, message: null };
+}
+
+async function checkWithPython(fullPath) {
+  for (const command of PYTHON_CANDIDATES) {
+    try {
+      await execFile(command, ["-m", "py_compile", fullPath], {
+        timeout: CHECK_TIMEOUT_MS,
+        windowsHide: true
+      });
+      return { checked: true, ok: true, message: null };
+    } catch (error) {
+      if (isMissingCommand(error)) {
+        continue;
+      }
+
+      return { checked: true, ok: false, message: extractErrorText(error) };
+    }
+  }
+
+  return { checked: false, ok: true, message: null };
+}
+
+async function checkWithNode(fullPath) {
+  try {
+    await execFile(process.execPath, ["--check", fullPath], {
+      timeout: CHECK_TIMEOUT_MS,
+      windowsHide: true
+    });
+    return { checked: true, ok: true, message: null };
+  } catch (error) {
+    return { checked: true, ok: false, message: extractErrorText(error) };
+  }
+}
+
+function isMissingCommand(error) {
+  return error && (error.code === "ENOENT" || error.errno === "ENOENT");
+}
+
+function extractErrorText(error) {
+  const text = [error?.stderr, error?.stdout, error?.message].filter(Boolean).join("\n").trim();
+  return text || "Unknown syntax error.";
+}

package/src/tools.js

@@ -0,0 +1,105 @@
+import { checkSyntax } from "./syntaxCheck.js";
+import { confirmCommand } from "./ui.js";
+
+export function createToolset(workspace) {
+  const tools = {
+    list_files: {
+      description: "List files under the workspace or a subdirectory.",
+      args: { path: "string?", limit: "number?" },
+      run: async ({ path = ".", limit = 200 }) => workspace.listFiles(path, limit)
+    },
+    read_file: {
+      description: "Read a UTF-8 text file from the workspace.",
+      args: { path: "string" },
+      run: async ({ path }) => workspace.readFile(path)
+    },
+    write_file: {
+      description: [
+        "Create or overwrite a UTF-8 file inside the workspace.",
+        "For files longer than ~40 lines, write a small skeleton first (imports and function signatures), then use append_file to add the rest in smaller pieces.",
+        "Do not use this to add to a file that already has content you want to keep - use append_file instead, so you never have to retype existing content."
+      ].join(" "),
+      args: { path: "string", content: "string" },
+      run: async ({ path, content }) => withSyntaxCheck(workspace, path, () => workspace.writeFile(path, content))
+    },
+    append_file: {
+      description: "Append content to the end of a file, creating it if it does not exist. Prefer this over write_file when a file already has content you want to keep.",
+      args: { path: "string", content: "string" },
+      run: async ({ path, content }) => withSyntaxCheck(workspace, path, () => workspace.appendFile(path, content))
+    },
+    replace_in_file: {
+      description: "Replace text inside an existing file.",
+      args: {
+        path: "string",
+        findText: "string",
+        replaceText: "string",
+        replaceAll: "boolean?"
+      },
+      run: async (args) => withSyntaxCheck(
+        workspace,
+        args.path,
+        () => workspace.replaceInFile(args.path, args.findText, args.replaceText, args.replaceAll)
+      )
+    },
+    search_text: {
+      description: "Search for a plain text query across workspace files.",
+      args: { query: "string", path: "string?", limit: "number?" },
+      run: async ({ query, path = ".", limit = 50 }) => workspace.searchText(query, path, limit)
+    },
+    make_directory: {
+      description: "Create a directory recursively in the workspace.",
+      args: { path: "string" },
+      run: async ({ path }) => workspace.makeDirectory(path)
+    },
+    run_command: {
+      description: "Run a local shell command inside the workspace (e.g. dotnet run, npm test, python script.py) to build, test, or execute code. Unless the session was started with --allow-commands, the user is asked to approve each command in the terminal before it runs.",
+      args: { command: "string", args: "string[]?" },
+      run: async ({ command, args = [] }) => {
+        if (workspace.allowCommands) {
+          return workspace.runCommand(command, args);
+        }
+
+        const approved = await confirmCommand({ command, args, cwd: workspace.rootPath });
+        return workspace.runCommand(command, args, { approved });
+      }
+    }
+  };
+
+  return {
+    tools,
+    getManifest() {
+      return Object.entries(tools).map(([name, value]) => ({
+        name,
+        description: value.description,
+        args: value.args
+      }));
+    },
+    async execute(name, args, allowedTools = null) {
+      const tool = tools[name];
+      if (!tool) {
+        throw new Error(`Unknown tool: ${name}`);
+      }
+
+      if (allowedTools && !allowedTools.includes(name)) {
+        throw new Error(`Tool "${name}" is not available for this task. Allowed tools: ${allowedTools.join(", ")}`);
+      }
+
+      return tool.run(args ?? {});
+    }
+  };
+}
+
+async function withSyntaxCheck(workspace, targetPath, writeAction) {
+  const message = await writeAction();
+  const result = await checkSyntax(workspace.resolvePath(targetPath));
+
+  if (!result.checked) {
+    return message;
+  }
+
+  if (result.ok) {
+    return `${message}\nSyntax OK.`;
+  }
+
+  return `${message}\n⚠️ Syntax check failed:\n${result.message}`;
+}

package/src/ui.js

@@ -0,0 +1,281 @@
+import readline from "node:readline";
+import readlinePromises from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+const ANSI = {
+  reset: "\u001b[0m",
+  bold: "\u001b[1m",
+  dim: "\u001b[2m",
+  cyan: "\u001b[36m",
+  green: "\u001b[32m",
+  yellow: "\u001b[33m",
+  red: "\u001b[31m",
+  gray: "\u001b[90m"
+};
+
+export async function selectMenu({ title, subtitle = "", headerLines = [], options, footer = "" }) {
+  if (!isInteractive()) {
+    throw new Error("Interactive menu requires a TTY.");
+  }
+
+  const enabledIndexes = options
+    .map((option, index) => ({ option, index }))
+    .filter((entry) => !entry.option.disabled)
+    .map((entry) => entry.index);
+
+  if (enabledIndexes.length === 0) {
+    throw new Error("Interactive menu has no selectable options.");
+  }
+
+  let selectedIndex = enabledIndexes[0];
+
+  return new Promise((resolve, reject) => {
+    readline.emitKeypressEvents(input);
+    const previousRawMode = typeof input.setRawMode === "function" ? input.isRaw : false;
+    if (typeof input.setRawMode === "function") {
+      input.setRawMode(true);
+    }
+
+    const cleanup = () => {
+      input.removeListener("keypress", onKeypress);
+      if (typeof input.setRawMode === "function") {
+        input.setRawMode(previousRawMode);
+      }
+      output.write("\n");
+    };
+
+    const render = () => {
+      console.clear();
+      const lines = [];
+      lines.push(style(title, "bold"));
+      if (subtitle) {
+        lines.push(style(subtitle, "dim"));
+      }
+      if (headerLines.length > 0) {
+        lines.push("");
+        lines.push(...headerLines);
+      }
+      lines.push("");
+
+      for (let index = 0; index < options.length; index += 1) {
+        const option = options[index];
+        const focused = index === selectedIndex;
+        const pointer = focused ? color("> ", "cyan") : "  ";
+        const label = focused ? style(option.label, "bold") : option.label;
+        const status = color(
+          option.badgeLabel ?? (option.disabled ? "unavailable" : "ready"),
+          option.badgeTone ?? (option.disabled ? "red" : "green")
+        );
+        lines.push(`${pointer}${label} ${style(`[${status}]`, "dim")}`);
+
+        if (option.description) {
+          lines.push(`  ${style(option.description, option.disabled ? "gray" : "dim")}`);
+        }
+
+        if (option.hint) {
+          lines.push(`  ${style(option.hint, option.disabled ? "yellow" : "gray")}`);
+        }
+
+        lines.push("");
+      }
+
+      if (footer) {
+        lines.push(style(footer, "dim"));
+      }
+
+      output.write(lines.join("\n"));
+    };
+
+    const onKeypress = (_, key) => {
+      if (!key) {
+        return;
+      }
+
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        reject(new Error("Cancelled by user."));
+        return;
+      }
+
+      if (key.name === "up") {
+        selectedIndex = moveSelection(options, enabledIndexes, selectedIndex, -1);
+        render();
+        return;
+      }
+
+      if (key.name === "down") {
+        selectedIndex = moveSelection(options, enabledIndexes, selectedIndex, 1);
+        render();
+        return;
+      }
+
+      if (key.name === "return") {
+        const option = options[selectedIndex];
+        cleanup();
+        resolve(option.value);
+      }
+    };
+
+    input.on("keypress", onKeypress);
+    render();
+  });
+}
+
+export function printSplash({ workspace, command }) {
+  if (!isInteractive()) {
+    return;
+  }
+
+  console.log(renderStartupDashboard({ workspace, command }));
+}
+
+export async function withSpinner(message, task) {
+  if (!isInteractive()) {
+    return task();
+  }
+
+  const frames = ["|", "/", "-", "\\"];
+  let frameIndex = 0;
+  const render = () => {
+    output.write(`\r${color(frames[frameIndex], "cyan")} ${message}`);
+    frameIndex = (frameIndex + 1) % frames.length;
+  };
+
+  render();
+  const timer = setInterval(render, 90);
+
+  try {
+    const result = await task();
+    clearInterval(timer);
+    output.write(`\r${color("OK", "green")} ${message}\n`);
+    return result;
+  } catch (error) {
+    clearInterval(timer);
+    output.write(`\r${color("ERR", "red")} ${message}\n`);
+    throw error;
+  }
+}
+
+export async function confirmCommand({ command, args = [], cwd }) {
+  if (!isInteractive()) {
+    return false;
+  }
+
+  const commandLine = [command, ...args].join(" ");
+  output.write(`\n${style("Model wants to run:", "yellow")} ${commandLine}\n`);
+  output.write(`${style("Working directory:", "dim")} ${cwd}\n`);
+
+  const rl = readlinePromises.createInterface({ input, output });
+  try {
+    const answer = (await rl.question("Allow this command? [y/N]: ")).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+export function printNote(message) {
+  console.log(style(message, "dim"));
+}
+
+export function renderStartupDashboard({
+  workspace,
+  command,
+  lastUsedProvider = "",
+  lastUsedModel = "",
+  lastTaskSummary = "",
+  readyCount,
+  totalProviders,
+  readyProviders = [],
+  recentFiles = []
+}) {
+  const lines = [
+    style("local-code-agent", "bold"),
+    style("Local coding CLI for Ollama and LM Studio", "dim"),
+    style("--------------------------------------------------", "gray"),
+    `${style("Workspace", "cyan")} : ${workspace}`,
+    `${style("Command", "cyan")}   : ${command}`
+  ];
+
+  if (lastUsedProvider || lastUsedModel) {
+    lines.push(`${style("Last used", "cyan")} : ${formatLastUsed(lastUsedProvider, lastUsedModel)}`);
+  } else {
+    lines.push(`${style("Last used", "cyan")} : none saved yet`);
+  }
+
+  if (lastTaskSummary) {
+    lines.push(`${style("Last task", "cyan")} : ${lastTaskSummary}`);
+  }
+
+  if (typeof readyCount === "number" && typeof totalProviders === "number") {
+    lines.push(`${style("Ready now", "cyan")}  : ${readyCount}/${totalProviders}`);
+  }
+
+  if (readyProviders.length > 0) {
+    lines.push(`${style("Online", "cyan")}    : ${readyProviders.join(", ")}`);
+  }
+
+  if (recentFiles.length > 0) {
+    lines.push(`${style("Recent files", "cyan")} : ${recentFiles.join(", ")}`);
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}
+
+export function renderDiagnostics(title, sections) {
+  const lines = [style(title, "bold"), ""];
+
+  for (const section of sections) {
+    lines.push(section.heading);
+    for (const line of section.lines) {
+      lines.push(line);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n").trimEnd();
+}
+
+export function color(text, tone) {
+  if (!supportsAnsi()) {
+    return text;
+  }
+
+  const code = ANSI[tone];
+  if (!code) {
+    return text;
+  }
+
+  return `${code}${text}${ANSI.reset}`;
+}
+
+export function style(text, tone) {
+  return color(text, tone);
+}
+
+export function supportsAnsi() {
+  return Boolean(output.isTTY && process.env.TERM !== "dumb");
+}
+
+export function isInteractive() {
+  return Boolean(input.isTTY && output.isTTY);
+}
+
+function moveSelection(options, enabledIndexes, currentIndex, direction) {
+  const currentPosition = enabledIndexes.indexOf(currentIndex);
+  const nextPosition = (currentPosition + direction + enabledIndexes.length) % enabledIndexes.length;
+  const nextIndex = enabledIndexes[nextPosition];
+
+  if (options[nextIndex]?.disabled) {
+    return currentIndex;
+  }
+
+  return nextIndex;
+}
+
+function formatLastUsed(provider, model) {
+  const savedProvider = provider || "unknown provider";
+  const savedModel = model || "no model saved";
+  return `${savedProvider} / ${savedModel}`;
+}

package/src/workspace.js

@@ -0,0 +1,224 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+const DEFAULT_IGNORES = new Set([
+  ".git",
+  "node_modules",
+  ".DS_Store"
+]);
+
+export class Workspace {
+  constructor(rootPath, options = {}) {
+    this.rootPath = path.resolve(rootPath);
+    this.allowCommands = Boolean(options.allowCommands);
+  }
+
+  resolvePath(targetPath = ".") {
+    const normalizedTarget = targetPath === "" ? "." : targetPath;
+    const fullPath = path.resolve(this.rootPath, normalizedTarget);
+    const relative = path.relative(this.rootPath, fullPath);
+
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+      throw new Error(`Path escapes workspace: ${targetPath}`);
+    }
+
+    return fullPath;
+  }
+
+  async listFiles(targetPath = ".", limit = 200) {
+    const startPath = this.resolvePath(targetPath);
+    const results = [];
+    await walk(startPath, this.rootPath, results, limit);
+    return results;
+  }
+
+  async listRecentFiles(limit = 5) {
+    const results = [];
+    await walkRecent(this.rootPath, this.rootPath, results);
+
+    return results
+      .sort((left, right) => right.modifiedAt.localeCompare(left.modifiedAt))
+      .slice(0, limit);
+  }
+
+  async readFile(targetPath) {
+    const fullPath = this.resolvePath(targetPath);
+    return fs.readFile(fullPath, "utf8");
+  }
+
+  async writeFile(targetPath, content) {
+    const fullPath = this.resolvePath(targetPath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content, "utf8");
+    return `Wrote ${path.relative(this.rootPath, fullPath)}`;
+  }
+
+  async appendFile(targetPath, content) {
+    const fullPath = this.resolvePath(targetPath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.appendFile(fullPath, content, "utf8");
+    return `Appended to ${path.relative(this.rootPath, fullPath)}`;
+  }
+
+  async replaceInFile(targetPath, findText, replaceText, replaceAll = false) {
+    const fullPath = this.resolvePath(targetPath);
+    const current = await fs.readFile(fullPath, "utf8");
+    if (!current.includes(findText)) {
+      throw new Error(`Text not found in ${targetPath}`);
+    }
+
+    const updated = replaceAll
+      ? current.split(findText).join(replaceText)
+      : current.replace(findText, replaceText);
+    await fs.writeFile(fullPath, updated, "utf8");
+    return `Updated ${targetPath}`;
+  }
+
+  async searchText(query, targetPath = ".", limit = 50) {
+    const files = await this.listFiles(targetPath, 500);
+    const matches = [];
+    for (const relativePath of files) {
+      if (matches.length >= limit) {
+        break;
+      }
+
+      const content = await this.readFile(relativePath);
+      const lines = content.split(/\r?\n/);
+      for (let index = 0; index < lines.length; index += 1) {
+        if (lines[index].includes(query)) {
+          matches.push({
+            path: relativePath,
+            line: index + 1,
+            text: lines[index].trim()
+          });
+          if (matches.length >= limit) {
+            break;
+          }
+        }
+      }
+    }
+
+    return matches;
+  }
+
+  async makeDirectory(targetPath) {
+    const fullPath = this.resolvePath(targetPath);
+    await fs.mkdir(fullPath, { recursive: true });
+    return `Created ${path.relative(this.rootPath, fullPath)}`;
+  }
+
+  async runCommand(command, args = [], { approved = false } = {}) {
+    if (!this.allowCommands && !approved) {
+      throw new Error("Command execution was not approved. Re-run with --allow-commands to skip the prompt, or approve it when asked.");
+    }
+
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, args, {
+        cwd: this.rootPath,
+        shell: process.platform === "win32",
+        env: { ...process.env, NO_COLOR: "1", FORCE_COLOR: "0" }
+      });
+
+      let stdout = "";
+      let stderr = "";
+
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+
+      child.on("error", (error) => {
+        reject(error);
+      });
+
+      child.on("close", (code) => {
+        resolve({
+          code,
+          stdout: stdout.trimEnd(),
+          stderr: stderr.trimEnd()
+        });
+      });
+    });
+  }
+}
+
+const MAX_SCANNED_ENTRIES = 5000;
+
+async function walk(currentPath, rootPath, results, limit) {
+  if (results.length >= limit) {
+    return;
+  }
+
+  let entries;
+  try {
+    entries = await fs.readdir(currentPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (results.length >= limit) {
+      return;
+    }
+
+    if (DEFAULT_IGNORES.has(entry.name)) {
+      continue;
+    }
+
+    const fullPath = path.join(currentPath, entry.name);
+    const relativePath = path.relative(rootPath, fullPath).replace(/\\/g, "/");
+
+    if (entry.isDirectory()) {
+      await walk(fullPath, rootPath, results, limit);
+      continue;
+    }
+
+    results.push(relativePath);
+  }
+}
+
+async function walkRecent(currentPath, rootPath, results, scanned = { count: 0 }) {
+  if (scanned.count >= MAX_SCANNED_ENTRIES) {
+    return;
+  }
+
+  let entries;
+  try {
+    entries = await fs.readdir(currentPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (scanned.count >= MAX_SCANNED_ENTRIES) {
+      return;
+    }
+
+    if (DEFAULT_IGNORES.has(entry.name)) {
+      continue;
+    }
+
+    scanned.count += 1;
+    const fullPath = path.join(currentPath, entry.name);
+    const relativePath = path.relative(rootPath, fullPath).replace(/\\/g, "/");
+
+    if (entry.isDirectory()) {
+      await walkRecent(fullPath, rootPath, results, scanned);
+      continue;
+    }
+
+    try {
+      const stat = await fs.stat(fullPath);
+      results.push({
+        path: relativePath,
+        modifiedAt: stat.mtime.toISOString()
+      });
+    } catch {
+      // Skip files we can't stat (permissions, broken symlinks, etc).
+    }
+  }
+}