@opencoven/coven-code 0.0.4 → 0.0.7

package/src/skills/discover.mjs

@@ -1,95 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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}` };
-}

package/src/tools/builtin/finder.mjs

@@ -1,73 +0,0 @@
-import { resolvePermissionDecision } from '../../commands/permissions.mjs';
-import { runPluginEventHandlers } from '../../plugins/discover.mjs';
-import { listThreads, threadSearchText } from '../../threads/store.mjs';
-import { isToolDisabled } from '../toolbox.mjs';
-import {
-  applyToolCallDecision,
-  createToolUseID,
-  permissionDeniedOutput,
-  pluginTextToolRunResult,
-  pluginToolCallEvent,
-  pluginToolResultEvent,
-  pluginToolUseBlock,
-  toolCallDecisionToolRun,
-  validateToolCallDecision,
-} from './runtime.mjs';
-
-export const TOOL_NAME = 'finder';
-
-export async function executePromptFinderToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '', toolName = TOOL_NAME) {
-  if (isToolDisabled(toolName, 'built-in', parsed)) return { output: `Tool disabled: ${toolName}` };
-  request = { ...request, flags: normalizeFinderInput(request.flags) };
-  if (!request.flags.query) return { output: `${toolName} requires --query` };
-  const toolUseID = createToolUseID();
-  const callDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.call'],
-    pluginToolCallEvent(toolName, request.flags, threadId, toolUseID),
-    validateToolCallDecision,
-  );
-  const callResult = applyToolCallDecision(toolName, request, callDecision);
-  if (callResult.output) return toolCallDecisionToolRun(toolName, request.flags, toolUseID, callResult);
-  request = { ...callResult.request, flags: normalizeFinderInput(callResult.request.flags) };
-  const decision = resolvePermissionDecision(toolName, request.flags, parsed, { threadId });
-  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
-    return {
-      output: permissionDeniedOutput(toolName, decision),
-      permissionDenials: [{ tool: toolName, action: decision.action, reason: 'permission' }],
-    };
-  }
-  const output = findThreadsBuiltin(request.flags.query, request.flags.limit);
-  const resultDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.result'],
-    pluginToolResultEvent(toolName, request.flags, 'done', output, threadId, toolUseID),
-  );
-  return {
-    ...pluginTextToolRunResult(resultDecision, output),
-    toolUse: pluginToolUseBlock(toolName, request.flags, toolUseID),
-  };
-}
-
-function normalizeFinderInput(input = {}) {
-  const query = input.query ?? input.q ?? input.search ?? input.task ?? input.file;
-  const limit = Number.parseInt(String(input.limit ?? input.count ?? 10), 10);
-  return {
-    ...input,
-    query: query ? String(query) : '',
-    limit: Number.isFinite(limit) && limit > 0 ? Math.min(limit, 50) : 10,
-  };
-}
-
-function findThreadsBuiltin(query, limit = 10) {
-  const normalizedQuery = query.toLowerCase();
-  const rows = listThreads()
-    .filter((thread) => threadSearchText(thread).toLowerCase().includes(normalizedQuery))
-    .slice(0, limit)
-    .map((thread) => [
-      thread.id,
-      thread.archived ? 'archived' : 'active',
-      thread.visibility ?? 'private',
-      thread.labels?.length ? thread.labels.join(',') : '-',
-      thread.title,
-    ].join('\t'));
-  return rows.length ? rows.join('\n') : `No threads found for ${query}`;
-}

package/src/tools/builtin/glob.mjs

@@ -1,74 +0,0 @@
-import path from 'node:path';
-import { resolvePermissionDecision } from '../../commands/permissions.mjs';
-import { runPluginEventHandlers } from '../../plugins/discover.mjs';
-import { globToRegex, walkFiles } from '../../util/glob.mjs';
-import { isToolDisabled } from '../toolbox.mjs';
-import {
-  applyToolCallDecision,
-  createToolUseID,
-  permissionDeniedOutput,
-  pluginTextToolRunResult,
-  pluginToolCallEvent,
-  pluginToolResultEvent,
-  pluginToolUseBlock,
-  relativeToolPath,
-  toolCallDecisionToolRun,
-  validateToolCallDecision,
-} from './runtime.mjs';
-
-export const TOOL_NAME = 'glob';
-
-export async function executePromptGlobToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
-  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
-  request = { ...request, flags: normalizeGlobInput(request.flags) };
-  if (!request.flags.pattern) return { output: 'glob requires --pattern' };
-  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: normalizeGlobInput(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 = globBuiltinFiles(request.flags.pattern, request.flags.path);
-  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 normalizeGlobInput(input = {}) {
-  const pattern = input.pattern ?? input.glob ?? input.query;
-  const searchPath = input.path ?? input.dir ?? input.cwd ?? '.';
-  return {
-    ...input,
-    pattern: pattern ? String(pattern) : '',
-    path: searchPath ? String(searchPath) : '.',
-  };
-}
-
-function globBuiltinFiles(pattern, searchPath = '.') {
-  const root = path.isAbsolute(searchPath) ? searchPath : path.resolve(process.cwd(), searchPath);
-  const absolutePattern = path.isAbsolute(pattern) ? path.normalize(pattern) : path.normalize(path.join(root, pattern));
-  const matchers = [globToRegex(absolutePattern)];
-  if (!path.isAbsolute(pattern) && pattern.startsWith('**/')) {
-    matchers.push(globToRegex(path.normalize(path.join(root, pattern.slice('**/'.length)))));
-  }
-  return walkFiles(root)
-    .filter((filePath) => matchers.some((matcher) => matcher.test(path.normalize(filePath))))
-    .map(relativeToolPath)
-    .sort()
-    .join('\n');
-}