opencode-dux 1.0.0

package/src/tools/ast-grep/tools.ts

@@ -0,0 +1,117 @@
+import { type ToolDefinition, tool } from '@opencode-ai/plugin/tool';
+import { runSg } from './cli';
+import type { CliLanguage } from './types';
+import { CLI_LANGUAGES } from './types';
+import {
+  formatReplaceResult,
+  formatSearchResult,
+  getEmptyResultHint,
+} from './utils';
+
+function showOutputToUser(context: unknown, output: string): void {
+  const ctx = context as {
+    metadata?: (input: { metadata: { output: string } }) => void;
+  };
+  ctx.metadata?.({ metadata: { output } });
+}
+
+export const ast_grep_search: ToolDefinition = tool({
+  description:
+    'Search code patterns across filesystem using AST-aware matching. Supports 25 languages. ' +
+    'Use meta-variables: $VAR (single node), $$$ (multiple nodes). ' +
+    'IMPORTANT: Patterns must be complete AST nodes (valid code). ' +
+    "For functions, include params and body: 'export async function $NAME($$$) { $$$ }' not 'export async function $NAME'. " +
+    "Examples: 'console.log($MSG)', 'def $FUNC($$$):', 'async function $NAME($$$)'",
+  args: {
+    pattern: tool.schema
+      .string()
+      .describe(
+        'AST pattern with meta-variables ($VAR, $$$). Must be complete AST node.',
+      ),
+    lang: tool.schema.enum(CLI_LANGUAGES).describe('Target language'),
+    paths: tool.schema
+      .array(tool.schema.string())
+      .optional()
+      .describe("Paths to search (default: ['.'])"),
+    globs: tool.schema
+      .array(tool.schema.string())
+      .optional()
+      .describe('Include/exclude globs (prefix ! to exclude)'),
+    context: tool.schema
+      .number()
+      .optional()
+      .describe('Context lines around match'),
+  },
+  execute: async (args, context) => {
+    try {
+      const result = await runSg({
+        pattern: args.pattern,
+        lang: args.lang as CliLanguage,
+        paths: args.paths,
+        globs: args.globs,
+        context: args.context,
+      });
+
+      let output = formatSearchResult(result);
+
+      if (result.matches.length === 0 && !result.error) {
+        const hint = getEmptyResultHint(args.pattern, args.lang as CliLanguage);
+        if (hint) {
+          output += `\n\n${hint}`;
+        }
+      }
+
+      showOutputToUser(context, output);
+      return output;
+    } catch (e) {
+      const output = `Error: ${e instanceof Error ? e.message : String(e)}`;
+      showOutputToUser(context, output);
+      return output;
+    }
+  },
+});
+
+export const ast_grep_replace: ToolDefinition = tool({
+  description:
+    'Replace code patterns across filesystem with AST-aware rewriting. ' +
+    'Dry-run by default. Use meta-variables in rewrite to preserve matched content. ' +
+    "Example: pattern='console.log($MSG)' rewrite='logger.info($MSG)'",
+  args: {
+    pattern: tool.schema.string().describe('AST pattern to match'),
+    rewrite: tool.schema
+      .string()
+      .describe('Replacement pattern (can use $VAR from pattern)'),
+    lang: tool.schema.enum(CLI_LANGUAGES).describe('Target language'),
+    paths: tool.schema
+      .array(tool.schema.string())
+      .optional()
+      .describe('Paths to search'),
+    globs: tool.schema
+      .array(tool.schema.string())
+      .optional()
+      .describe('Include/exclude globs'),
+    dryRun: tool.schema
+      .boolean()
+      .optional()
+      .describe('Preview changes without applying (default: true)'),
+  },
+  execute: async (args, context) => {
+    try {
+      const result = await runSg({
+        pattern: args.pattern,
+        rewrite: args.rewrite,
+        lang: args.lang as CliLanguage,
+        paths: args.paths,
+        globs: args.globs,
+        updateAll: args.dryRun === false,
+      });
+      const output = formatReplaceResult(result, args.dryRun !== false);
+      showOutputToUser(context, output);
+      return output;
+    } catch (e) {
+      const output = `Error: ${e instanceof Error ? e.message : String(e)}`;
+      showOutputToUser(context, output);
+      return output;
+    }
+  },
+});

package/src/tools/ast-grep/types.ts

@@ -0,0 +1,51 @@
+// CLI supported languages (25 total)
+export const CLI_LANGUAGES = [
+  'bash',
+  'c',
+  'cpp',
+  'csharp',
+  'css',
+  'elixir',
+  'go',
+  'haskell',
+  'html',
+  'java',
+  'javascript',
+  'json',
+  'kotlin',
+  'lua',
+  'nix',
+  'php',
+  'python',
+  'ruby',
+  'rust',
+  'scala',
+  'solidity',
+  'swift',
+  'typescript',
+  'tsx',
+  'yaml',
+] as const;
+
+export type CliLanguage = (typeof CLI_LANGUAGES)[number];
+
+export interface CliMatch {
+  file: string;
+  range: {
+    byteOffset: { start: number; end: number };
+    start: { line: number; column: number };
+    end: { line: number; column: number };
+  };
+  lines: string;
+  text: string;
+  replacement?: string;
+  language: string;
+}
+
+export interface SgResult {
+  matches: CliMatch[];
+  totalMatches: number;
+  truncated: boolean;
+  truncatedReason?: 'timeout' | 'max_output_bytes' | 'max_matches';
+  error?: string;
+}

package/src/tools/ast-grep/utils.ts

@@ -0,0 +1,126 @@
+import type { CliLanguage, SgResult } from './types';
+
+export function formatSearchResult(result: SgResult): string {
+  if (result.error) {
+    return `Error: ${result.error}`;
+  }
+
+  if (result.matches.length === 0) {
+    return 'No matches found.';
+  }
+
+  const lines: string[] = [];
+
+  // Group matches by file
+  const byFile = new Map<string, typeof result.matches>();
+  for (const match of result.matches) {
+    const existing = byFile.get(match.file) || [];
+    existing.push(match);
+    byFile.set(match.file, existing);
+  }
+
+  for (const [file, matches] of byFile) {
+    lines.push(`\n${file}:`);
+    for (const match of matches) {
+      const startLine = match.range.start.line + 1;
+      const text =
+        match.text.length > 100
+          ? `${match.text.substring(0, 100)}...`
+          : match.text;
+      lines.push(`  ${startLine}: ${text.replace(/\n/g, '\\n')}`);
+    }
+  }
+
+  const fileCount = byFile.size;
+  const summary = `Found ${result.totalMatches} matches in ${fileCount} files`;
+  if (result.truncated) {
+    lines.push(`\n${summary} (output truncated: ${result.truncatedReason})`);
+  } else {
+    lines.push(`\n${summary}`);
+  }
+
+  return lines.join('\n');
+}
+
+export function formatReplaceResult(
+  result: SgResult,
+  isDryRun: boolean,
+): string {
+  if (result.error) {
+    return `Error: ${result.error}`;
+  }
+
+  if (result.matches.length === 0) {
+    return 'No matches found for replacement.';
+  }
+
+  const lines: string[] = [];
+  const mode = isDryRun ? '[DRY RUN]' : '[APPLIED]';
+
+  // Group by file
+  const byFile = new Map<string, typeof result.matches>();
+  for (const match of result.matches) {
+    const existing = byFile.get(match.file) || [];
+    existing.push(match);
+    byFile.set(match.file, existing);
+  }
+
+  for (const [file, matches] of byFile) {
+    lines.push(`\n${file}:`);
+    for (const match of matches) {
+      const startLine = match.range.start.line + 1;
+      const original =
+        match.text.length > 60
+          ? `${match.text.substring(0, 60)}...`
+          : match.text;
+      const replacement = match.replacement
+        ? match.replacement.length > 60
+          ? `${match.replacement.substring(0, 60)}...`
+          : match.replacement
+        : '[no replacement]';
+      lines.push(
+        `  ${startLine}: "${original.replace(/\n/g, '\\n')}" → "${replacement.replace(/\n/g, '\\n')}"`,
+      );
+    }
+  }
+
+  const fileCount = byFile.size;
+  lines.push(
+    `\n${mode} ${result.totalMatches} replacements in ${fileCount} files`,
+  );
+
+  if (isDryRun) {
+    lines.push('\nTo apply changes, run with dryRun=false');
+  }
+
+  return lines.join('\n');
+}
+
+export function getEmptyResultHint(
+  pattern: string,
+  lang: CliLanguage,
+): string | null {
+  const src = pattern.trim();
+
+  if (lang === 'python') {
+    if (src.startsWith('class ') && src.endsWith(':')) {
+      const withoutColon = src.slice(0, -1);
+      return `Hint: Remove trailing colon. Try: "${withoutColon}"`;
+    }
+    if (
+      (src.startsWith('def ') || src.startsWith('async def ')) &&
+      src.endsWith(':')
+    ) {
+      const withoutColon = src.slice(0, -1);
+      return `Hint: Remove trailing colon. Try: "${withoutColon}"`;
+    }
+  }
+
+  if (['javascript', 'typescript', 'tsx'].includes(lang)) {
+    if (/^(export\s+)?(async\s+)?function\s+\$[A-Z_]+\s*$/i.test(src)) {
+      return `Hint: Function patterns need params and body. Try "function $NAME($$$) { $$$ }"`;
+    }
+  }
+
+  return null;
+}

package/src/tools/delegate-handoff.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'bun:test';
+import { subagentOutputRequestsUserHandoff } from './delegate';
+
+describe('subagentOutputRequestsUserHandoff', () => {
+  test('true when <needs_user> is present', () => {
+    expect(
+      subagentOutputRequestsUserHandoff(
+        '<diagnosis>x</diagnosis><needs_user>clarify</needs_user>',
+      ),
+    ).toBe(true);
+  });
+
+  test('false when only blocked', () => {
+    expect(subagentOutputRequestsUserHandoff('<blocked>x</blocked>')).toBe(
+      false,
+    );
+  });
+});