@jc20231028/local-code-agent 0.1.0 → 0.1.3

package/src/skills.js

@@ -1,130 +1,130 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-export const RESERVED_NAMES = new Set(["exit", "provider", "model", "status", "skills", "reset"]);
-
-export function parseSkillFile(raw, sourcePath, scope) {
-  const frontmatterMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
-  if (!frontmatterMatch) {
-    throw new Error(`Missing frontmatter in ${sourcePath}`);
-  }
-
-  const [, frontmatterBlock, body] = frontmatterMatch;
-  const fields = {};
-  for (const line of frontmatterBlock.split(/\r?\n/)) {
-    if (!line.trim()) {
-      continue;
-    }
-
-    const separatorIndex = line.indexOf(":");
-    if (separatorIndex === -1) {
-      continue;
-    }
-
-    const key = line.slice(0, separatorIndex).trim();
-    const value = line.slice(separatorIndex + 1).trim();
-    fields[key] = value;
-  }
-
-  if (!fields.name) {
-    throw new Error(`Missing "name" field in ${sourcePath}`);
-  }
-
-  if (!fields.description) {
-    throw new Error(`Missing "description" field in ${sourcePath}`);
-  }
-
-  return {
-    name: fields.name,
-    description: fields.description,
-    keywords: parseList(fields.keywords),
-    tools: fields.tools ? parseList(fields.tools) : null,
-    body: body.trim(),
-    sourcePath,
-    scope
-  };
-}
-
-export async function loadSkills(workspace, options = {}) {
-  const homeDir = options.homeDir ?? os.homedir();
-  const skills = new Map();
-
-  await loadSkillsFromDir(path.join(homeDir, ".local-code", "skills"), "user", skills);
-  await loadSkillsFromDir(path.join(workspace, ".local-code", "skills"), "project", skills);
-
-  return skills;
-}
-
-export function matchSkillInvocation(prompt, skills) {
-  const match = prompt.match(/^\/(\S+)\s*([\s\S]*)$/);
-  if (!match) {
-    return { type: "none" };
-  }
-
-  const [, token, rest] = match;
-  const skill = skills.get(token.toLowerCase());
-  if (!skill) {
-    return { type: "unknown", token };
-  }
-
-  return { type: "skill", skill, rest: rest.trim() };
-}
-
-export function buildSkillPrompt(skill, rest) {
-  return [`[Skill: ${skill.name}]`, skill.body, "", `Task: ${rest}`].join("\n");
-}
-
-async function loadSkillsFromDir(dirPath, scope, skills) {
-  let entries;
-  try {
-    entries = await fs.readdir(dirPath, { withFileTypes: true });
-  } catch {
-    return;
-  }
-
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md")) {
-      continue;
-    }
-
-    const fullPath = path.join(dirPath, entry.name);
-
-    let skill;
-    try {
-      const raw = await fs.readFile(fullPath, "utf8");
-      skill = parseSkillFile(raw, fullPath, scope);
-    } catch (error) {
-      console.error(`Skipping invalid skill file ${fullPath}: ${error.message}`);
-      continue;
-    }
-
-    const lowerName = skill.name.toLowerCase();
-    if (RESERVED_NAMES.has(lowerName)) {
-      console.error(`Skipping skill "${skill.name}" in ${fullPath}: name is reserved.`);
-      continue;
-    }
-
-    skills.set(lowerName, skill);
-    for (const keyword of skill.keywords) {
-      const lowerKeyword = keyword.toLowerCase();
-      if (RESERVED_NAMES.has(lowerKeyword)) {
-        console.error(`Skipping keyword "${keyword}" for skill "${skill.name}": name is reserved.`);
-        continue;
-      }
-
-      skills.set(lowerKeyword, skill);
-    }
-  }
-}
-
-function parseList(value) {
-  if (!value) {
-    return [];
-  }
-
-  return value
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean);
-}
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+export const RESERVED_NAMES = new Set(["exit", "provider", "model", "status", "skills", "reset"]);
+
+export function parseSkillFile(raw, sourcePath, scope) {
+  const frontmatterMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    throw new Error(`Missing frontmatter in ${sourcePath}`);
+  }
+
+  const [, frontmatterBlock, body] = frontmatterMatch;
+  const fields = {};
+  for (const line of frontmatterBlock.split(/\r?\n/)) {
+    if (!line.trim()) {
+      continue;
+    }
+
+    const separatorIndex = line.indexOf(":");
+    if (separatorIndex === -1) {
+      continue;
+    }
+
+    const key = line.slice(0, separatorIndex).trim();
+    const value = line.slice(separatorIndex + 1).trim();
+    fields[key] = value;
+  }
+
+  if (!fields.name) {
+    throw new Error(`Missing "name" field in ${sourcePath}`);
+  }
+
+  if (!fields.description) {
+    throw new Error(`Missing "description" field in ${sourcePath}`);
+  }
+
+  return {
+    name: fields.name,
+    description: fields.description,
+    keywords: parseList(fields.keywords),
+    tools: fields.tools ? parseList(fields.tools) : null,
+    body: body.trim(),
+    sourcePath,
+    scope
+  };
+}
+
+export async function loadSkills(workspace, options = {}) {
+  const homeDir = options.homeDir ?? os.homedir();
+  const skills = new Map();
+
+  await loadSkillsFromDir(path.join(homeDir, ".local-code", "skills"), "user", skills);
+  await loadSkillsFromDir(path.join(workspace, ".local-code", "skills"), "project", skills);
+
+  return skills;
+}
+
+export function matchSkillInvocation(prompt, skills) {
+  const match = prompt.match(/^\/(\S+)\s*([\s\S]*)$/);
+  if (!match) {
+    return { type: "none" };
+  }
+
+  const [, token, rest] = match;
+  const skill = skills.get(token.toLowerCase());
+  if (!skill) {
+    return { type: "unknown", token };
+  }
+
+  return { type: "skill", skill, rest: rest.trim() };
+}
+
+export function buildSkillPrompt(skill, rest) {
+  return [`[Skill: ${skill.name}]`, skill.body, "", `Task: ${rest}`].join("\n");
+}
+
+async function loadSkillsFromDir(dirPath, scope, skills) {
+  let entries;
+  try {
+    entries = await fs.readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      continue;
+    }
+
+    const fullPath = path.join(dirPath, entry.name);
+
+    let skill;
+    try {
+      const raw = await fs.readFile(fullPath, "utf8");
+      skill = parseSkillFile(raw, fullPath, scope);
+    } catch (error) {
+      console.error(`Skipping invalid skill file ${fullPath}: ${error.message}`);
+      continue;
+    }
+
+    const lowerName = skill.name.toLowerCase();
+    if (RESERVED_NAMES.has(lowerName)) {
+      console.error(`Skipping skill "${skill.name}" in ${fullPath}: name is reserved.`);
+      continue;
+    }
+
+    skills.set(lowerName, skill);
+    for (const keyword of skill.keywords) {
+      const lowerKeyword = keyword.toLowerCase();
+      if (RESERVED_NAMES.has(lowerKeyword)) {
+        console.error(`Skipping keyword "${keyword}" for skill "${skill.name}": name is reserved.`);
+        continue;
+      }
+
+      skills.set(lowerKeyword, skill);
+    }
+  }
+}
+
+function parseList(value) {
+  if (!value) {
+    return [];
+  }
+
+  return value
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}

package/src/syntaxCheck.js

@@ -1,62 +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.";
-}
+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

@@ -1,105 +1,130 @@
-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}`;
-}
+import { checkSyntax } from "./syntaxCheck.js";
+import { confirmCommand, confirmWrite } 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.",
+        "Unless the session was started with --allow-writes, the user is asked to approve each file change in the terminal before it is written."
+      ].join(" "),
+      args: { path: "string", content: "string" },
+      run: async ({ path, content }) => {
+        const approved = await approveWrite(workspace, { action: "write", path, preview: content });
+        return withSyntaxCheck(workspace, path, () => workspace.writeFile(path, content, { approved }));
+      }
+    },
+    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 }) => {
+        const approved = await approveWrite(workspace, { action: "append", path, preview: content });
+        return withSyntaxCheck(workspace, path, () => workspace.appendFile(path, content, { approved }));
+      }
+    },
+    replace_in_file: {
+      description: "Replace text inside an existing file.",
+      args: {
+        path: "string",
+        findText: "string",
+        replaceText: "string",
+        replaceAll: "boolean?"
+      },
+      run: async (args) => {
+        const approved = await approveWrite(workspace, {
+          action: "replace",
+          path: args.path,
+          preview: `Find:\n${args.findText}\nReplace with:\n${args.replaceText}`
+        });
+        return withSyntaxCheck(
+          workspace,
+          args.path,
+          () => workspace.replaceInFile(args.path, args.findText, args.replaceText, args.replaceAll, { approved })
+        );
+      }
+    },
+    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 }) => {
+        const approved = await approveWrite(workspace, { action: "mkdir", path });
+        return workspace.makeDirectory(path, { approved });
+      }
+    },
+    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 approveWrite(workspace, { action, path, preview }) {
+  if (workspace.allowWrites) {
+    return true;
+  }
+
+  return confirmWrite({ action, path, preview, cwd: workspace.rootPath });
+}
+
+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}`;
+}