@opencoven/coven-code 0.0.4 → 0.0.6

package/src/tools/builtin/web-search.mjs

@@ -1,128 +0,0 @@
-import { resolvePermissionDecision } from '../../commands/permissions.mjs';
-import { runPluginEventHandlers } from '../../plugins/discover.mjs';
-import { decodeHtmlText } from '../../util/html.mjs';
-import { isToolDisabled } from '../toolbox.mjs';
-import {
-  applyToolCallDecision,
-  createToolUseID,
-  permissionDeniedOutput,
-  pluginTextToolRunResult,
-  pluginToolCallEvent,
-  pluginToolResultEvent,
-  pluginToolUseBlock,
-  toolCallDecisionToolRun,
-  validateToolCallDecision,
-} from './runtime.mjs';
-
-export const TOOL_NAME = 'web_search';
-
-export async function executePromptWebSearchToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
-  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
-  request = { ...request, flags: normalizeWebSearchInput(request.flags) };
-  if (!request.flags.query) return { output: 'web_search requires --query' };
-  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: normalizeWebSearchInput(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 = await searchWebBuiltin(request.flags.query, request.flags.limit);
-  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 normalizeWebSearchInput(input = {}) {
-  const query = input.query ?? input.q ?? input.search;
-  const limit = Number.parseInt(String(input.limit ?? input.count ?? 5), 10);
-  return {
-    ...input,
-    query: query ? String(query) : '',
-    limit: Number.isFinite(limit) && limit > 0 ? Math.min(limit, 10) : 5,
-  };
-}
-
-async function searchWebBuiltin(query, limit = 5) {
-  const fixture = webSearchFixtureResults(limit);
-  if (fixture) return formatWebSearchResults(fixture, query);
-
-  try {
-    const url = `https://html.duckduckgo.com/html/?${new URLSearchParams({ q: query }).toString()}`;
-    const response = await fetch(url, {
-      headers: { 'user-agent': 'coven-code/0.0.0' },
-    });
-    if (!response.ok) return `Web search failed for ${query}: HTTP ${response.status}`;
-    const results = parseDuckDuckGoHtml(await response.text()).slice(0, limit);
-    return formatWebSearchResults(results, query);
-  } catch (error) {
-    return `Web search failed for ${query}: ${error.message}`;
-  }
-}
-
-function webSearchFixtureResults(limit) {
-  const fixtureJson = process.env.COVEN_CODE_WEB_SEARCH_RESULTS_JSON;
-  if (!fixtureJson) return undefined;
-  try {
-    const parsed = JSON.parse(fixtureJson);
-    return Array.isArray(parsed) ? parsed.slice(0, limit) : [];
-  } catch {
-    return [];
-  }
-}
-
-function parseDuckDuckGoHtml(html) {
-  const blocks = html.match(/<div[^>]+class="[^"]*result[^"]*"[\s\S]*?(?=<div[^>]+class="[^"]*result[^"]*"|<\/body>)/g) ?? [];
-  return blocks
-    .map((block) => {
-      const link = block.match(/<a[^>]+class="[^"]*result__a[^"]*"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/);
-      if (!link) return undefined;
-      const snippet = block.match(/<a[^>]+class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/)
-        ?? block.match(/<div[^>]+class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/div>/);
-      return {
-        title: cleanHtmlText(link[2]),
-        url: cleanDuckDuckGoUrl(decodeHtmlText(link[1])),
-        snippet: snippet ? cleanHtmlText(snippet[1]) : '',
-      };
-    })
-    .filter(Boolean);
-}
-
-function cleanDuckDuckGoUrl(url) {
-  try {
-    const parsed = new URL(url);
-    const redirected = parsed.searchParams.get('uddg');
-    return redirected ? decodeURIComponent(redirected) : url;
-  } catch {
-    return url;
-  }
-}
-
-function cleanHtmlText(value = '') {
-  return decodeHtmlText(value.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim());
-}
-
-function formatWebSearchResults(results = [], query = '') {
-  if (results.length === 0) return `No web search results found for ${query}`;
-  return results
-    .map((result, index) => [
-      `${index + 1}. ${result.title ?? 'Untitled'}`,
-      result.url ?? '',
-      result.snippet ?? '',
-    ].filter(Boolean).join('\n'))
-    .join('\n\n');
-}

package/src/tools/toolbox.mjs

@@ -1,273 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import path from 'node:path';
-import { BUILTIN_TOOLS } from '../constants.mjs';
-import { toolsDirs } from '../settings/paths.mjs';
-import { readEffectiveSettings } from '../settings/load.mjs';
-import { globMatch } from '../util/glob.mjs';
-
-export function listToolboxTools(parsed = {}) {
-  const seen = new Set();
-  const tools = [];
-  for (const dir of toolsDirs(parsed)) {
-    if (!existsSync(dir)) continue;
-    for (const entry of readdirSync(dir)) {
-      const filePath = path.join(dir, entry);
-      if (!statSync(filePath).isFile()) continue;
-      const name = `tb__${path.basename(filePath)}`;
-      if (seen.has(name)) continue;
-      seen.add(name);
-      const schema = describeToolboxTool(filePath);
-      tools.push({ name, path: filePath, description: schema.description, schema });
-    }
-  }
-  return tools;
-}
-
-export function isToolDisabled(name, kind, parsed = {}) {
-  const settings = readEffectiveSettings(parsed);
-  const enabled = settings['covenCode.tools.enable'];
-  if (Array.isArray(enabled) && !enabled.some((pattern) => typeof pattern === 'string' && globMatch(pattern, name))) {
-    return true;
-  }
-  const disabled = settings['covenCode.tools.disable'];
-  if (!Array.isArray(disabled)) return false;
-  return disabled.some((pattern) => {
-    if (typeof pattern !== 'string') return false;
-    if (pattern.startsWith('builtin:')) {
-      return kind === 'built-in' && globMatch(pattern.slice('builtin:'.length), name);
-    }
-    return globMatch(pattern, name);
-  });
-}
-
-export function toolKindForName(name) {
-  if (BUILTIN_TOOLS.some(([builtinName]) => builtinName === name)) return 'built-in';
-  if (name.startsWith('tb__')) return 'toolbox';
-  if (name.startsWith('mcp__')) return 'local-mcp';
-  return '';
-}
-
-function describeToolboxTool(filePath) {
-  const result = spawnSync(filePath, {
-    env: { ...process.env, TOOLBOX_ACTION: 'describe', AGENT: 'coven-code' },
-    encoding: 'utf8',
-    shell: false,
-  });
-  return parseToolboxDescription(result.stdout, filePath);
-}
-
-function parseToolboxDescription(stdout, filePath) {
-  try {
-    const parsed = JSON.parse(stdout);
-    return {
-      format: 'json',
-      description: parsed.description || `Toolbox tool at ${filePath}`,
-      input: normalizeToolboxInputSchema(parsed.input ?? parsed.args ?? parsed.inputSchema ?? parsed.schema),
-      raw: parsed,
-    };
-  } catch {
-    // Fall through to the documented text format.
-  }
-
-  const lines = stdout.split(/\r?\n/).filter(Boolean);
-  const description = lines
-    .filter((line) => line.startsWith('description: '))
-    .map((line) => line.replace('description: ', '').trim())
-    .join('\n');
-  const input = lines
-    .filter((line) => !line.startsWith('name: ') && !line.startsWith('description: '))
-    .map((line) => {
-      const match = line.match(/^([^:]+):\s*(.*)$/);
-      return match ? parseTextParameter(match[1], match[2]) : undefined;
-    })
-    .filter(Boolean);
-  return {
-    format: 'text',
-    description: description || `Toolbox tool at ${filePath}`,
-    input,
-    raw: stdout,
-  };
-}
-
-function parseTextParameter(name, definition = '') {
-  const [first = '', ...rest] = definition.trim().split(/\s+/);
-  const knownTypes = new Set(['string', 'number', 'integer', 'boolean', 'array', 'object']);
-  if (!first || first.toLowerCase() === 'optional') {
-    return { name, type: 'string', description: ['optional', ...rest].filter(Boolean).join(' ') };
-  }
-  const optionalSuffix = first.endsWith('?');
-  const type = optionalSuffix ? first.slice(0, -1) : first;
-  if (knownTypes.has(type)) {
-    return { name, type, description: optionalText(rest.join(' '), optionalSuffix) };
-  }
-  return { name, type: 'string', description: definition.trim() };
-}
-
-function optionalText(description, optional) {
-  if (!optional) return description.replace(/^\(optional\)\s*/i, 'optional ');
-  return description.toLowerCase().startsWith('optional') ? description : `optional ${description}`.trim();
-}
-
-function normalizeToolboxInputSchema(input = {}) {
-  if (Array.isArray(input)) return input;
-  if (input?.type === 'object' && input.properties && typeof input.properties === 'object') {
-    return Object.entries(input.properties).map(([name, value]) => ({
-      name,
-      type: schemaTypeName(value),
-      description: value?.description || '',
-    }));
-  }
-  return Object.entries(input).map(([name, value]) => ({
-    name,
-    type: compactArgType(value),
-    description: compactArgDescription(value),
-  }));
-}
-
-function compactArgType(value) {
-  if (Array.isArray(value)) return value[0] || 'string';
-  return value?.type || 'string';
-}
-
-function compactArgDescription(value) {
-  if (Array.isArray(value)) return value[1] || '';
-  return value?.description || '';
-}
-
-function schemaTypeName(value = {}) {
-  const type = value.type || 'string';
-  if (type === 'array' && value.items?.type) return `array<${value.items.type}>`;
-  return type;
-}
-
-export function printToolboxSchema(tool) {
-  console.log(`# ${tool.name} (toolbox: ${tool.path})`);
-  console.log('');
-  console.log(tool.schema.description);
-  if (tool.schema.input.length === 0) return;
-  console.log('');
-  console.log('# Schema');
-  console.log('');
-  for (const input of tool.schema.input) {
-    const suffix = input.description ? `: ${input.description}` : '';
-    console.log(`- ${input.name} (${input.type})${suffix}`);
-  }
-}
-
-export function parseToolUseArgs(args) {
-  const result = {
-    toolName: '',
-    flags: {},
-    onlyOutput: false,
-    threadId: `T-${randomUUID()}`,
-  };
-
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index];
-    if (token === '--only' && args[index + 1] === 'output') {
-      result.onlyOutput = true;
-      index += 1;
-      continue;
-    }
-    if (token === '--thread') {
-      result.threadId = args[index + 1] ?? result.threadId;
-      index += 1;
-      continue;
-    }
-    if (token.startsWith('--')) {
-      const key = token.slice(2);
-      const value = args[index + 1] && !args[index + 1].startsWith('--') ? args[index + 1] : true;
-      if (value !== true) index += 1;
-      result.flags[key] = value;
-      continue;
-    }
-    if (!result.toolName) result.toolName = token;
-  }
-
-  return result;
-}
-
-function formatToolboxInput(tool, flags, stdin) {
-  if (stdin.length > 0) return stdin;
-  if (Object.keys(flags).length === 0) return '';
-  if (tool.schema.format === 'text') {
-    return Object.entries(flags).map(([key, value]) => `${key}: ${value}`).join('\n') + '\n';
-  }
-  return `${JSON.stringify(flags)}\n`;
-}
-
-export function normalizeToolName(name = '') {
-  return name.startsWith('tb__') ? name : `tb__${name}`;
-}
-
-export function toolboxTemplate(shell, name) {
-  if (shell === 'js') return javascriptToolboxTemplate(name);
-  return `#!/usr/bin/env ${shell}
-set -euo pipefail
-
-if [ "\${TOOLBOX_ACTION:-describe}" = "describe" ]; then
-  cat <<'EOF'
-name: ${name}
-description: ${name.replaceAll('_', ' ')} toolbox tool
-input: string optional Input passed to the tool
-EOF
-  exit 0
-fi
-
-input="$(cat || true)"
-if [ -n "$input" ]; then
-  printf '%s\\n' "$input"
-else
-  printf '${name} executed\\n'
-fi
-`;
-}
-
-function javascriptToolboxTemplate(name) {
-  return `#!/usr/bin/env bun
-const action = process.env.TOOLBOX_ACTION ?? 'describe';
-
-if (action === 'describe') showDescription();
-else if (action === 'execute') execute();
-else {
-  console.error(\`Unknown action: \${action}\`);
-  process.exit(1);
-}
-
-function showDescription() {
-  process.stdout.write([
-    'name: ${name}',
-    'description: ${name.replaceAll('_', ' ')} toolbox tool',
-    'input: string optional Input passed to the tool',
-  ].join('\\n'));
-  process.stdout.write('\\n');
-}
-
-async function execute() {
-  const input = await new Response(Bun.stdin).text();
-  if (input.trim()) {
-    process.stdout.write(input.endsWith('\\n') ? input : \`\${input}\\n\`);
-  } else {
-    process.stdout.write('${name} executed\\n');
-  }
-}
-`;
-}
-
-export function executeToolboxTool(tool, flags, stdin, threadId) {
-  const input = formatToolboxInput(tool, flags, stdin);
-  return spawnSync(tool.path, {
-    input,
-    env: {
-      ...process.env,
-      TOOLBOX_ACTION: 'execute',
-      AGENT: 'coven-code',
-      COVEN_CODE_THREAD_ID: threadId,
-      AGENT_THREAD_ID: threadId,
-    },
-    encoding: 'utf8',
-    shell: false,
-  });
-}

package/src/util/fs.mjs

@@ -1,13 +0,0 @@
-import { existsSync } from 'node:fs';
-
-export function emitJson(value) {
-  process.stdout.write(`${JSON.stringify(value)}\n`);
-}
-
-export function displayCwd(cwd = process.cwd()) {
-  return String(cwd).replace(/^\/private\/var\//, '/var/');
-}
-
-export function addIfExists(files, filePath) {
-  if (existsSync(filePath)) files.push(filePath);
-}

package/src/util/glob.mjs

@@ -1,46 +0,0 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import path from 'node:path';
-
-export function globMatch(pattern, value) {
-  const re = new RegExp(`^${String(pattern).split('*').map(escapeRegex).join('.*')}$`);
-  return re.test(value);
-}
-
-export function escapeRegex(value) {
-  return value.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
-}
-
-export function hasGlob(rawPath) {
-  return /[*?]/.test(rawPath);
-}
-
-export function globToRegex(pattern) {
-  let source = '';
-  for (let index = 0; index < pattern.length; index += 1) {
-    const char = pattern[index];
-    const next = pattern[index + 1];
-    if (char === '*' && next === '*') {
-      source += '.*';
-      index += 1;
-    } else if (char === '*') {
-      source += `[^${escapeRegex(path.sep)}]*`;
-    } else if (char === '?') {
-      source += `[^${escapeRegex(path.sep)}]`;
-    } else {
-      source += escapeRegex(char);
-    }
-  }
-  return new RegExp(`^${source}$`);
-}
-
-export function walkFiles(dir) {
-  if (!existsSync(dir) || !statSync(dir).isDirectory()) return [];
-  const files = [];
-  for (const entry of readdirSync(dir)) {
-    const filePath = path.join(dir, entry);
-    const stat = statSync(filePath);
-    if (stat.isDirectory()) files.push(...walkFiles(filePath));
-    else if (stat.isFile()) files.push(filePath);
-  }
-  return files;
-}

package/src/util/html.mjs

@@ -1,21 +0,0 @@
-export function decodeHtmlText(value = '') {
-  return value
-    .replace(new RegExp('&' + 'a' + 'mp;', 'g'), '&')
-    .replace(/"/g, '"')
-    .replace(/'/g, "'")
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>');
-}
-
-export function htmlToText(html) {
-  return decodeHtmlText(html
-    .replace(/<script[\s\S]*?<\/script>/gi, '')
-    .replace(/<style[\s\S]*?<\/style>/gi, '')
-    .replace(/<\/(?:h[1-6]|p|div|main|article|section|li|tr)>/gi, '\n')
-    .replace(/<br\s*\/?>/gi, '\n')
-    .replace(/<[^>]+>/g, ' ')
-    .replace(/[ \t]+/g, ' ')
-    .replace(/\n\s+/g, '\n')
-    .replace(/\n{3,}/g, '\n\n')
-    .trim());
-}

package/src/util/media.mjs

@@ -1,13 +0,0 @@
-export function detectImageMediaType(raw) {
-  if (raw.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return 'image/png';
-  if (raw[0] === 0xff && raw[1] === 0xd8 && raw[2] === 0xff) return 'image/jpeg';
-  const header = raw.subarray(0, 12).toString('ascii');
-  if (header.startsWith('GIF87a') || header.startsWith('GIF89a')) return 'image/gif';
-  if (header.startsWith('RIFF') && header.slice(8, 12) === 'WEBP') return 'image/webp';
-  return undefined;
-}
-
-export function imageMediaTypeExtension(mediaType) {
-  if (mediaType === 'image/jpeg') return 'jpg';
-  return mediaType.split('/').at(-1) || 'img';
-}

package/src/util/shell.mjs

@@ -1,24 +0,0 @@
-import { readFileSync } from 'node:fs';
-
-export function splitShellWords(line) {
-  const tokens = [];
-  const re = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|(\S+)/g;
-  let match;
-  while ((match = re.exec(line))) {
-    tokens.push((match[1] ?? match[2] ?? match[3]).replace(/\\(["'])/g, '$1'));
-  }
-  return tokens;
-}
-
-export function shellQuote(value) {
-  return `'${String(value).replace(/'/g, `'\\''`)}'`;
-}
-
-export function readStdin() {
-  if (process.stdin.isTTY) return '';
-  try {
-    return readFileSync(0, 'utf8');
-  } catch {
-    return '';
-  }
-}

package/src/util/table.mjs

@@ -1,11 +0,0 @@
-export function printRows(rows) {
-  const widths = [];
-  for (const row of rows) {
-    row.forEach((cell, index) => {
-      widths[index] = Math.max(widths[index] ?? 0, String(cell).length);
-    });
-  }
-  for (const row of rows) {
-    console.log(row.map((cell, index) => String(cell).padEnd(widths[index])).join('  ').trimEnd());
-  }
-}