@opencoven/coven-code 0.0.1

package/src/settings/paths.mjs

@@ -0,0 +1,101 @@
+import { existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { CONFIG_SUBDIR, PROJECT_SUBDIR } from '../constants.mjs';
+
+const TOOLBOX_ENV = 'COVEN_CODE_TOOLBOX';
+const SETTINGS_FILE_ENV = 'COVEN_CODE_SETTINGS_FILE';
+const MANAGED_SETTINGS_FILE_ENV = 'COVEN_CODE_MANAGED_SETTINGS_FILE';
+
+export function configDir() {
+  return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+}
+
+export function toolsDirs(parsed = {}) {
+  if (parsed.toolbox) return parsed.toolbox.split(path.delimiter).filter(Boolean).map(expandHomePath);
+  if (Object.hasOwn(process.env, TOOLBOX_ENV)) {
+    if (process.env[TOOLBOX_ENV] === '') return [];
+    return process.env[TOOLBOX_ENV].split(path.delimiter).filter(Boolean);
+  }
+  return [path.join(configDir(), CONFIG_SUBDIR, 'tools')];
+}
+
+export function writableToolsDir() {
+  return toolsDirs()[0] || path.join(configDir(), CONFIG_SUBDIR, 'tools');
+}
+
+export function workspaceSettingsFile(cwd) {
+  return path.join(cwd, PROJECT_SUBDIR, 'settings.json');
+}
+
+export function findWorkspaceSettingsFile(cwd) {
+  let current = path.resolve(cwd);
+  const boundary = findGitRoot(current) ?? current;
+  while (true) {
+    for (const name of ['settings.json', 'settings.jsonc']) {
+      const candidate = path.join(current, PROJECT_SUBDIR, name);
+      if (existsSync(candidate)) return candidate;
+    }
+    if (current === boundary) return undefined;
+    const parent = path.dirname(current);
+    if (parent === current) return undefined;
+    current = parent;
+  }
+}
+
+export function findUserSettingsFile() {
+  const dir = path.join(configDir(), CONFIG_SUBDIR);
+  for (const name of ['settings.json', 'settings.jsonc']) {
+    const candidate = path.join(dir, name);
+    if (existsSync(candidate)) return candidate;
+  }
+  return undefined;
+}
+
+export function findManagedSettingsFile() {
+  if (process.env[MANAGED_SETTINGS_FILE_ENV]) return process.env[MANAGED_SETTINGS_FILE_ENV];
+  const candidates = [];
+  if (process.platform === 'win32') {
+    if (process.env.ProgramData) {
+      candidates.push(path.join(process.env.ProgramData, CONFIG_SUBDIR, 'managed-settings.json'));
+    }
+  } else if (process.platform === 'darwin') {
+    candidates.push('/Library/Application Support/coven-code/managed-settings.json');
+  } else {
+    candidates.push('/etc/coven-code/managed-settings.json');
+  }
+  return candidates.find((candidate) => existsSync(candidate));
+}
+
+export function settingsFile(parsed = {}) {
+  if (parsed.settingsFile || process.env[SETTINGS_FILE_ENV]) {
+    return parsed.settingsFile || process.env[SETTINGS_FILE_ENV];
+  }
+  return findUserSettingsFile() || path.join(configDir(), CONFIG_SUBDIR, 'settings.json');
+}
+
+export function findProjectRoot(cwd) {
+  let current = cwd;
+  while (true) {
+    if (existsSync(path.join(current, 'package.json')) || existsSync(path.join(current, '.git'))) return current;
+    const parent = path.dirname(current);
+    if (parent === current || current === os.homedir()) return cwd;
+    current = parent;
+  }
+}
+
+function findGitRoot(cwd) {
+  let current = path.resolve(cwd);
+  while (true) {
+    if (existsSync(path.join(current, '.git'))) return current;
+    const parent = path.dirname(current);
+    if (parent === current || current === os.homedir()) return undefined;
+    current = parent;
+  }
+}
+
+export function expandHomePath(value) {
+  if (value === '~') return os.homedir();
+  if (value.startsWith(`~${path.sep}`)) return path.join(os.homedir(), value.slice(2));
+  return value;
+}

package/src/skills/builtin/building-skills/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: building-skills
+description: Create Coven Code skills for a codebase or workflow
+---
+
+# Building Skills
+
+Use this skill when the user asks to create a new Coven Code skill for a codebase,
+workflow, service, or repeated task.
+
+## Workflow
+
+1. Identify the task the skill should help with and where it should live.
+2. Create a skill directory with a `SKILL.md` file.
+3. Add YAML frontmatter with a unique `name` and concise `description`.
+4. Write clear instructions, examples, and any resource paths the agent should use.
+5. Keep the skill focused so it is loaded only when its description matches.
+
+Project skills live in `.agents/skills/<name>/`. User-wide skills live in
+`~/.config/agents/skills/<name>/`.

package/src/skills/discover.mjs

@@ -0,0 +1,95 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CONFIG_SUBDIR } from '../constants.mjs';
+import { configDir, expandHomePath } from '../settings/paths.mjs';
+import { readSettings } from '../settings/load.mjs';
+import { UsageError } from '../cli/parse.mjs';
+
+const BUILTIN_SKILLS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'builtin');
+
+export function listSkills(options = {}) {
+  const seen = new Set();
+  const skills = [];
+  for (const root of [...parsedSkillRoots(options.parsed), ...skillSearchRoots(options.cwd)]) {
+    if (!existsSync(root.dir)) continue;
+    for (const entry of readdirSync(root.dir)) {
+      const dir = path.join(root.dir, entry);
+      const filePath = path.join(dir, 'SKILL.md');
+      if (!existsSync(filePath) || !statSync(dir).isDirectory()) continue;
+      const metadata = readSkillMetadata(dir);
+      const skill = { ...metadata, dir, filePath, source: root.source };
+      if (options.includeShadowed || !seen.has(skill.name)) skills.push(skill);
+      seen.add(skill.name);
+    }
+  }
+  return skills;
+}
+
+export function findSkill(name) {
+  return listSkills().find((skill) => skill.name === name);
+}
+
+export function skillSearchRoots(cwd = process.cwd()) {
+  const userRoots = [
+    { source: 'user', dir: path.join(configDir(), 'agents', 'skills') },
+    { source: 'user', dir: path.join(configDir(), CONFIG_SUBDIR, 'skills') },
+    ...configuredSkillRoots(readSettings({})),
+  ];
+  const projectRoots = projectSkillRoots(cwd, '.agents', 'skills');
+  if (readSettings({})['covenCode.skills.disableLegacySkillRoots'] === true) return [...userRoots, ...projectRoots];
+  return [
+    ...userRoots,
+    ...projectRoots,
+    ...projectSkillRoots(cwd, '.claude', 'skills'),
+    { source: 'user', dir: path.join(os.homedir(), '.claude', 'skills') },
+    { source: 'built-in', dir: BUILTIN_SKILLS_DIR },
+  ];
+}
+
+function projectSkillRoots(cwd, ...parts) {
+  const roots = [];
+  const home = os.homedir();
+  let current = path.resolve(cwd);
+  while (true) {
+    roots.push({ source: 'project', dir: path.join(current, ...parts) });
+    if (current === home || current === path.dirname(current)) break;
+    current = path.dirname(current);
+  }
+  return roots;
+}
+
+export function parsedSkillRoots(parsed = {}) {
+  return splitSkillPath(parsed.skills).map((entry) => ({ source: 'cli', dir: expandHomePath(entry) }));
+}
+
+function configuredSkillRoots(settings) {
+  const rawPath = settings['covenCode.skills.path'];
+  return splitSkillPath(rawPath).map((entry) => ({ source: 'user', dir: expandHomePath(entry) }));
+}
+
+function splitSkillPath(rawPath) {
+  if (typeof rawPath !== 'string' || rawPath.trim() === '') return [];
+  return rawPath
+    .split(path.delimiter)
+    .filter(Boolean);
+}
+
+export function readSkillMetadata(dir) {
+  const filePath = path.join(dir, 'SKILL.md');
+  if (!existsSync(filePath)) throw new UsageError(`Skill at ${dir} is missing SKILL.md`);
+  const text = readFileSync(filePath, 'utf8');
+  const frontmatter = text.match(/^---\n([\s\S]*?)\n---/);
+  const metadata = {};
+  if (frontmatter) {
+    for (const line of frontmatter[1].split(/\r?\n/)) {
+      const match = line.match(/^([A-Za-z0-9_.-]+):\s*(.*)$/);
+      if (match) metadata[match[1]] = match[2].replace(/^["']|["']$/g, '');
+    }
+  }
+  return {
+    name: metadata.name || path.basename(dir),
+    description: metadata.description || '',
+  };
+}

package/src/threads/store.mjs

@@ -0,0 +1,176 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { CONFIG_SUBDIR } from '../constants.mjs';
+import { configDir } from '../settings/paths.mjs';
+import { readEffectiveSettings, readSettingsFile, writeSettingsFile } from '../settings/load.mjs';
+import { displayCwd } from '../util/fs.mjs';
+import { UsageError } from '../cli/parse.mjs';
+
+export const THREAD_VISIBILITIES = ['private', 'public', 'workspace', 'group', 'unlisted'];
+export const THREAD_VISIBILITY_INPUTS = ['private', 'public', 'workspace', 'workspace-shared', 'group', 'group-shared', 'unlisted'];
+
+export function threadsDir() {
+  return path.join(configDir(), CONFIG_SUBDIR, 'threads');
+}
+
+export function threadFile(id) {
+  return path.join(threadsDir(), `${id}.json`);
+}
+
+export function readThread(id) {
+  const filePath = threadFile(id);
+  if (!existsSync(filePath)) return undefined;
+  return readSettingsFile(filePath);
+}
+
+export function listThreads() {
+  const dir = threadsDir();
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((entry) => entry.endsWith('.json'))
+    .map((entry) => readSettingsFile(path.join(dir, entry)))
+    .filter((thread) => thread.id)
+    .sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)));
+}
+
+export function latestActiveThread() {
+  return listThreads()
+    .filter((thread) => !thread.archived)
+    .sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)))[0];
+}
+
+export async function writeThread(thread) {
+  await writeSettingsFile(threadFile(thread.id), thread);
+}
+
+export function requireThread(id) {
+  if (!id) throw new UsageError('threads command requires a thread id');
+  const thread = readThread(id);
+  if (!thread) throw new UsageError(`Unknown thread: ${id}`);
+  return thread;
+}
+
+export function threadSearchText(thread) {
+  return [
+    thread.id,
+    thread.title,
+    thread.cwd,
+    thread.createdAt,
+    thread.updatedAt,
+    ...(thread.labels ?? []),
+    ...(thread.messages ?? []).map((message) => message.content),
+  ].join(' ');
+}
+
+export function defaultThreadVisibility(parsed = {}) {
+  const configured = readEffectiveSettings(parsed)['covenCode.defaultVisibility'];
+  const originKey = currentRepositoryOriginKey();
+  const visibility = typeof configured === 'string'
+    ? configured
+    : configured?.[originKey] ?? configured?.default;
+  return normalizeThreadVisibility(parsed.visibility) ?? normalizeThreadVisibility(visibility) ?? 'private';
+}
+
+export function normalizeThreadVisibility(visibility) {
+  if (visibility === 'workspace-shared') return 'workspace';
+  if (visibility === 'group-shared') return 'group';
+  return THREAD_VISIBILITIES.includes(visibility) ? visibility : undefined;
+}
+
+export async function saveThread(id, prompt, result, mode, parsed = {}) {
+  return saveThreadMessages(id, [
+    { role: 'user', content: prompt },
+    { role: 'assistant', content: result },
+  ], mode, parsed);
+}
+
+export async function persistThreadTurn(id, prompt, result, mode, thread, parsed = {}) {
+  return persistThreadMessages(id, [
+    { role: 'user', content: prompt },
+    { role: 'assistant', content: result },
+  ], mode, thread, parsed);
+}
+
+export async function saveThreadMessages(id, messages, mode, parsed = {}) {
+  const now = new Date().toISOString();
+  const firstUser = messages.find((message) => message.role === 'user')?.content ?? '';
+  const existing = readThread(id);
+  const thread = {
+    id,
+    title: existing?.title === '(pending thread)' || !existing?.title
+      ? firstUser.split(/\r?\n/).find(Boolean)?.slice(0, 120) || '(empty prompt)'
+      : existing.title,
+    cwd: displayCwd(),
+    mode,
+    visibility: defaultThreadVisibility(parsed),
+    labels: normalizedLabels(parsed.labels),
+    archived: Boolean(parsed.archive),
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    messages: [...(existing?.messages ?? []), ...messages],
+  };
+  await writeThread(thread);
+  return thread;
+}
+
+export async function persistThreadMessages(id, messages, mode, thread, parsed = {}) {
+  if (!thread) {
+    return saveThreadMessages(id, messages, mode, parsed);
+  }
+  thread.mode = mode;
+  thread.visibility = normalizeThreadVisibility(parsed.visibility) ?? thread.visibility;
+  thread.labels = mergeLabels(thread.labels, parsed.labels);
+  if (parsed.archive) thread.archived = true;
+  thread.updatedAt = new Date().toISOString();
+  thread.messages.push(...messages);
+  await writeThread(thread);
+  return thread;
+}
+
+export function threadContinuationPrompt(thread, prompt) {
+  return `[thread:${thread.id}]\n${thread.messages.map((message) => `${message.role}: ${message.content}`).join('\n')}\n[/thread]\n${prompt}`;
+}
+
+function normalizedLabels(labels = []) {
+  return [...new Set(labels.map((label) => String(label).trim()).filter(Boolean))];
+}
+
+function mergeLabels(existing = [], labels = []) {
+  return [...new Set([...existing, ...normalizedLabels(labels)])];
+}
+
+function currentRepositoryOriginKey() {
+  const configPath = findGitConfig(process.cwd());
+  if (!configPath) return undefined;
+  try {
+    const config = readFileSync(configPath, 'utf8');
+    const originUrl = config.match(/\[remote "origin"\][\s\S]*?\n\s*url\s*=\s*([^\r\n]+)/)?.[1]?.trim();
+    return normalizeGitOrigin(originUrl);
+  } catch {
+    return undefined;
+  }
+}
+
+function findGitConfig(cwd) {
+  let current = path.resolve(cwd);
+  while (true) {
+    const candidate = path.join(current, '.git', 'config');
+    if (existsSync(candidate)) return candidate;
+    const parent = path.dirname(current);
+    if (parent === current || current === path.resolve(configDir(), '..')) return undefined;
+    current = parent;
+  }
+}
+
+function normalizeGitOrigin(originUrl = '') {
+  const text = originUrl.replace(/\.git$/, '');
+  const scp = text.match(/^git@([^:]+):(.+)$/);
+  if (scp) return `${scp[1]}/${scp[2]}`;
+  try {
+    const url = new URL(text);
+    const pathName = url.pathname.replace(/^\/+/, '');
+    return pathName ? `${url.hostname}/${pathName}` : undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/tools/builtin/bash.mjs

@@ -0,0 +1,110 @@
+import { spawnSync } from 'node:child_process';
+import { THREAD_URL_BASE } from '../../constants.mjs';
+import { resolvePermissionDecision } from '../../commands/permissions.mjs';
+import { runPluginEventHandlers } from '../../plugins/discover.mjs';
+import { readEffectiveSettings } from '../../settings/load.mjs';
+import { shellQuote, splitShellWords } from '../../util/shell.mjs';
+import { isToolDisabled } from '../toolbox.mjs';
+import {
+  applyToolCallDecision,
+  createToolUseID,
+  permissionDeniedOutput,
+  pluginResultOutput,
+  pluginToolCallEvent,
+  pluginToolResultDecisionExitCode,
+  pluginToolResultEvent,
+  pluginToolUseBlock,
+  toolCallDecisionToolRun,
+  validateToolCallDecision,
+} from './runtime.mjs';
+
+export const TOOL_NAME = 'Bash';
+
+export async function executePromptBashToolRequest(request, stdin = '', parsed = {}, plugins = { handlers: {} }, threadId = '') {
+  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
+  request = { ...request, flags: normalizeBashInput(request.flags) };
+  if (!request.flags.command) return { output: 'Bash requires --command' };
+  const toolUseID = createToolUseID();
+  const callDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.call'],
+    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
+    validateToolCallDecision,
+  );
+  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
+  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
+  request = { ...callResult.request, flags: normalizeBashInput(callResult.request.flags) };
+  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
+  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
+    return {
+      output: permissionDeniedOutput(TOOL_NAME, decision),
+      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
+    };
+  }
+  const result = spawnSync(commandForBashExecution(request.flags.command, parsed, threadId), {
+    cwd: process.cwd(),
+    input: stdin,
+    shell: true,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      COVEN_CODE_THREAD_ID: threadId,
+      AGENT_THREAD_ID: threadId,
+    },
+  });
+  if (result.stderr) process.stderr.write(result.stderr);
+  process.exitCode = result.status ?? 0;
+  const output = (result.stdout ?? '').trimEnd();
+  const resultDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.result'],
+    pluginToolResultEvent(TOOL_NAME, request.flags, (result.status ?? 0) === 0 ? 'done' : 'error', output, threadId, toolUseID),
+  );
+  const exitCode = pluginToolResultDecisionExitCode(resultDecision, result.status ?? 0);
+  return {
+    output: pluginResultOutput(resultDecision, output),
+    exitCode,
+    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
+  };
+}
+
+function normalizeBashInput(input = {}) {
+  const command = String(input.command ?? input.cmd ?? '');
+  return { ...input, command, cmd: command };
+}
+
+function commandForBashExecution(command, parsed = {}, threadId = '') {
+  if (!isGitCommitCommand(command)) return command;
+  const trailers = gitCommitTrailers(parsed, threadId);
+  if (!trailers.length) return command;
+  return `${command} ${trailers.map((trailer) => `--trailer ${shellQuote(trailer)}`).join(' ')}`;
+}
+
+function isGitCommitCommand(command) {
+  const words = splitShellWords(command);
+  if (words[0] !== 'git') return false;
+  return gitSubcommand(words) === 'commit';
+}
+
+function gitSubcommand(words) {
+  for (let index = 1; index < words.length; index += 1) {
+    const word = words[index];
+    if (word === '-C' || word === '-c' || word === '--git-dir' || word === '--work-tree' || word === '--namespace') {
+      index += 1;
+      continue;
+    }
+    if (word.startsWith('-')) continue;
+    return word;
+  }
+  return '';
+}
+
+function gitCommitTrailers(parsed, threadId) {
+  const settings = readEffectiveSettings(parsed);
+  const trailers = [];
+  if (settings['covenCode.git.commit.thread.enabled'] !== false && threadId) {
+    trailers.push(`Coven-Code-Thread: ${THREAD_URL_BASE}/${threadId}`);
+  }
+  if (settings['covenCode.git.commit.coauthor.enabled'] === true) {
+    trailers.push('Co-authored-by: Coven Code <coven-code@opencoven.local>');
+  }
+  return trailers;
+}

package/src/tools/builtin/create-file.mjs

@@ -0,0 +1,66 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { resolvePermissionDecision } from '../../commands/permissions.mjs';
+import { runPluginEventHandlers } from '../../plugins/discover.mjs';
+import { isToolDisabled } from '../toolbox.mjs';
+import {
+  applyToolCallDecision,
+  createToolUseID,
+  permissionDeniedOutput,
+  pluginTextToolRunResult,
+  pluginToolCallEvent,
+  pluginToolResultEvent,
+  pluginToolUseBlock,
+  toolCallDecisionToolRun,
+  validateToolCallDecision,
+} from './runtime.mjs';
+
+export const TOOL_NAME = 'create_file';
+
+export async function executePromptCreateFileToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
+  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
+  request = { ...request, flags: normalizeCreateFileInput(request.flags) };
+  if (!request.flags.path) return { output: 'create_file requires --path' };
+  const toolUseID = createToolUseID();
+  const callDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.call'],
+    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
+    validateToolCallDecision,
+  );
+  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
+  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
+  request = { ...callResult.request, flags: normalizeCreateFileInput(callResult.request.flags) };
+  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
+  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
+    return {
+      output: permissionDeniedOutput(TOOL_NAME, decision),
+      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
+    };
+  }
+  const output = createBuiltinFile(request.flags.path, request.flags.content);
+  const resultDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.result'],
+    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
+  );
+  return {
+    ...pluginTextToolRunResult(resultDecision, output),
+    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
+  };
+}
+
+function normalizeCreateFileInput(input = {}) {
+  const filePath = input.path ?? input.file ?? input.file_path;
+  const content = input.content ?? input.text ?? input.body ?? '';
+  return {
+    ...input,
+    path: filePath ? String(filePath) : '',
+    content: String(content ?? ''),
+  };
+}
+
+function createBuiltinFile(filePath, content) {
+  const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
+  mkdirSync(path.dirname(absolutePath), { recursive: true });
+  writeFileSync(absolutePath, content, { encoding: 'utf8', flag: 'wx' });
+  return `Created ${filePath}`;
+}

package/src/tools/builtin/edit-file.mjs

@@ -0,0 +1,76 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { resolvePermissionDecision } from '../../commands/permissions.mjs';
+import { runPluginEventHandlers } from '../../plugins/discover.mjs';
+import { isToolDisabled } from '../toolbox.mjs';
+import {
+  applyToolCallDecision,
+  createToolUseID,
+  permissionDeniedOutput,
+  pluginTextToolRunResult,
+  pluginToolCallEvent,
+  pluginToolResultEvent,
+  pluginToolUseBlock,
+  toolCallDecisionToolRun,
+  validateToolCallDecision,
+} from './runtime.mjs';
+import { recordEditUndo } from './undo-edit.mjs';
+
+export const TOOL_NAME = 'edit_file';
+
+export async function executePromptEditFileToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
+  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
+  request = { ...request, flags: normalizeEditFileInput(request.flags) };
+  if (!request.flags.path) return { output: 'edit_file requires --path' };
+  if (!request.flags.old_string) return { output: 'edit_file requires --old' };
+  const toolUseID = createToolUseID();
+  const callDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.call'],
+    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
+    validateToolCallDecision,
+  );
+  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
+  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
+  request = { ...callResult.request, flags: normalizeEditFileInput(callResult.request.flags) };
+  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
+  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
+    return {
+      output: permissionDeniedOutput(TOOL_NAME, decision),
+      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
+    };
+  }
+  const editResult = editBuiltinFile(request.flags.path, request.flags.old_string, request.flags.new_string, threadId);
+  const resultDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.result'],
+    pluginToolResultEvent(TOOL_NAME, request.flags, editResult.status, editResult.output, threadId, toolUseID),
+  );
+  return {
+    ...pluginTextToolRunResult(resultDecision, editResult.output, editResult.status === 'done' ? 0 : 1),
+    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
+  };
+}
+
+function normalizeEditFileInput(input = {}) {
+  const filePath = input.path ?? input.file ?? input.file_path;
+  const oldString = input.old_string ?? input.old ?? input.search ?? input.find;
+  const newString = input.new_string ?? input.new ?? input.replacement ?? input.replace ?? '';
+  return {
+    ...input,
+    path: filePath ? String(filePath) : '',
+    old: oldString ? String(oldString) : '',
+    new: String(newString ?? ''),
+    old_string: oldString ? String(oldString) : '',
+    new_string: String(newString ?? ''),
+  };
+}
+
+function editBuiltinFile(filePath, oldString, newString, threadId = '') {
+  const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
+  const current = readFileSync(absolutePath, 'utf8');
+  if (!current.includes(oldString)) {
+    return { status: 'error', output: `No match found in ${filePath}` };
+  }
+  recordEditUndo(threadId, { path: filePath, absolutePath, content: current });
+  writeFileSync(absolutePath, current.replace(oldString, newString), 'utf8');
+  return { status: 'done', output: `Edited ${filePath}` };
+}