open-grok-build 0.1.0

package/src/tools/rendering.ts

@@ -0,0 +1,260 @@
+import { execFile } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export type RenderableText = { render: (width: number) => string[] };
+
+export const MAX_OUTPUT_CHARS = 50_000;
+export const MAX_OUTPUT_BYTES = MAX_OUTPUT_CHARS * 4 + 1024;
+export const MAX_LINES = 500;
+
+export function recordFrom(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== 'object') return undefined;
+  return value as Record<string, unknown>;
+}
+
+export function stringFrom(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  return value;
+}
+
+export function truncateLines(lines: string[]): string {
+  if (lines.length > MAX_LINES) {
+    return (
+      lines.slice(0, MAX_LINES).join('\n') +
+      `\n\n[Showing first ${MAX_LINES} of ${lines.length} results. Refine your pattern to narrow results.]`
+    );
+  }
+  return lines.join('\n');
+}
+
+export function truncateChars(output: string): string {
+  if (output.length > MAX_OUTPUT_CHARS) {
+    return `${output.slice(0, MAX_OUTPUT_CHARS)}\n\n[Output truncated at 50KB]`;
+  }
+  return output;
+}
+
+export function globToRegExp(pattern: string) {
+  let source = '^';
+  for (let i = 0; i < pattern.length; i += 1) {
+    const char = pattern[i];
+    const next = pattern[i + 1];
+    if (char === '*' && next === '*' && pattern[i + 2] === '/') {
+      source += '(?:.*/)?';
+      i += 2;
+    } else if (char === '*' && next === '*') {
+      source += '.*';
+      i += 1;
+    } else if (char === '*') {
+      source += '[^/]*';
+    } else if (char === '?') {
+      source += '[^/]';
+    } else {
+      source += char.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+    }
+  }
+  return new RegExp(`${source}$`);
+}
+
+export function normalizePath(filePath: string) {
+  return filePath.replaceAll('\\', '/');
+}
+
+export async function listFilesRecursive(
+  searchPath: string,
+  signal?: AbortSignal,
+): Promise<string[]> {
+  if (signal?.aborted) throw new Error('The operation was aborted');
+  const stats = await fs.stat(searchPath);
+  if (stats.isFile()) return [searchPath];
+  if (!stats.isDirectory()) return [];
+
+  return (
+    await Promise.all(
+      (
+        await fs.readdir(searchPath, { withFileTypes: true })
+      ).map((entry) => {
+        const entryPath = join(searchPath, entry.name);
+        if (entry.isDirectory()) return listFilesRecursive(entryPath, signal);
+        if (entry.isFile()) return [entryPath];
+        return [];
+      }),
+    )
+  ).flat();
+}
+
+let rgAvailable: boolean | undefined;
+export async function hasRipgrep(): Promise<boolean> {
+  if (rgAvailable !== undefined) return rgAvailable;
+  try {
+    await execFileAsync('rg', ['--version']);
+    rgAvailable = true;
+  } catch {
+    rgAvailable = false;
+  }
+  return rgAvailable;
+}
+
+export type ToolError = { code?: number; message?: string };
+export type ToolResult<T> = {
+  content: [{ type: 'text'; text: string }];
+  details: T;
+};
+
+export function text(content: string): RenderableText {
+  return {
+    render: () => [content],
+  };
+}
+
+function firstText(result: { content: { type: string; text?: string }[] }) {
+  const first = result.content[0];
+  if (first?.type !== 'text') return undefined;
+  return first.text;
+}
+
+export function renderResultText(
+  result: { content: { type: string; text?: string }[] },
+  expanded: boolean,
+  summary: string,
+): RenderableText {
+  if (expanded) return text(firstText(result) ?? summary);
+  return text(summary);
+}
+
+export function renderRunning(isPartial: boolean): RenderableText | undefined {
+  if (!isPartial) return undefined;
+  return text('Running...');
+}
+
+export function renderResultSummary(
+  result: { content: { type: string; text?: string }[] },
+  expanded: boolean,
+  isPartial: boolean,
+  summary: string,
+): RenderableText {
+  const running = renderRunning(isPartial);
+  if (running) return running;
+  return renderResultText(result, expanded, summary);
+}
+
+export function detailRecord(result: { details: unknown }): Record<string, unknown> {
+  if (!result.details || typeof result.details !== 'object') return {};
+  return result.details as Record<string, unknown>;
+}
+
+export function numberDetail(result: { details: unknown }, key: string): number {
+  const value = detailRecord(result)[key];
+  if (typeof value !== 'number') return 0;
+  return value;
+}
+
+export function stringDetail(result: { details: unknown }, key: string): string {
+  const value = detailRecord(result)[key];
+  if (typeof value !== 'string') return '';
+  return value;
+}
+
+export function booleanDetail(result: { details: unknown }, key: string): boolean {
+  const value = detailRecord(result)[key];
+  return value === true;
+}
+
+type FileDetails = { path: string; [key: string]: unknown };
+
+export function fileNotFound<T extends FileDetails>(
+  filePath: string,
+  extraDetails: Omit<T, 'path'>,
+): ToolResult<T> {
+  return {
+    content: [{ type: 'text', text: `File not found: ${filePath}` }],
+    details: { path: filePath, ...extraDetails } as T,
+  };
+}
+
+export function fileError<T extends FileDetails>(
+  error: unknown,
+  toolName: string,
+  filePath: string,
+  extraDetails: Omit<T, 'path'>,
+): ToolResult<T> {
+  const err = error as ToolError;
+  const message = err.message ?? 'Unknown error';
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `${toolName} error: ${message}`,
+      },
+    ],
+    details: { path: filePath, ...extraDetails, failed: true, error: message } as unknown as T,
+  };
+}
+
+export function toolError<T>(error: unknown, toolName: string, emptyDetails: T): ToolResult<T> {
+  const err = error as ToolError;
+  if (toolName === 'Grep' && err.code === 1) {
+    return {
+      content: [{ type: 'text', text: 'No matches found' }],
+      details: emptyDetails,
+    };
+  }
+  const message = err.message ?? 'Unknown error';
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `${toolName} error: ${message}`,
+      },
+    ],
+    details: { ...emptyDetails, failed: true, error: message } as T,
+  };
+}
+
+export async function execWithRgFallback(
+  rgArgs: string[],
+  options: {
+    cwd: string;
+    signal?: AbortSignal;
+    pattern: string;
+    searchPath: string;
+    include?: string;
+  },
+): Promise<string> {
+  if (await hasRipgrep()) {
+    const result = await execFileAsync('rg', rgArgs, {
+      cwd: options.cwd,
+      maxBuffer: MAX_OUTPUT_BYTES,
+      signal: options.signal,
+    });
+    return result.stdout;
+  }
+
+  const regex = new RegExp(options.pattern);
+  const matcher = options.include ? globToRegExp(normalizePath(options.include)) : undefined;
+  return (
+    await Promise.all(
+      (
+        await listFilesRecursive(options.searchPath, options.signal)
+      )
+        .filter((file) => {
+          if (!matcher) return true;
+          if (!options.include?.includes('/')) return matcher.test(basename(file));
+          return matcher.test(normalizePath(relative(options.cwd, file)));
+        })
+        .map(async (file) =>
+          (
+            await fs.readFile(file, 'utf8')
+          )
+            .split(/\r?\n/)
+            .flatMap((line, index) => (regex.test(line) ? `${file}:${index + 1}:${line}` : [])),
+        ),
+    )
+  )
+    .flat()
+    .join('\n');
+}

package/src/tools/search.ts

@@ -0,0 +1,195 @@
+// @ts-nocheck
+import { execFile } from 'node:child_process';
+import { statSync } from 'node:fs';
+import { basename, relative, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import {
+  execWithRgFallback,
+  globToRegExp,
+  hasRipgrep,
+  listFilesRecursive,
+  MAX_OUTPUT_BYTES,
+  normalizePath,
+  numberDetail,
+  recordFrom,
+  renderResultText,
+  renderRunning,
+  stringFrom,
+  text,
+  toolError,
+  truncateChars,
+  truncateLines,
+} from './rendering.js';
+import type { ToolRegistrar } from './types.js';
+
+const execFileAsync = promisify(execFile);
+
+type GrepArgs = { pattern: string; path?: string; include?: string };
+type GlobArgs = { pattern: string; path?: string };
+
+function modifiedTimeMs(file: string) {
+  try {
+    return statSync(file).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+export function sortByModifiedNewest(files: string[]) {
+  return files.sort((a, b) => {
+    const delta = modifiedTimeMs(b) - modifiedTimeMs(a);
+    if (delta !== 0) return delta;
+    return a.localeCompare(b);
+  });
+}
+
+export function registerSearchTools(registrar: ToolRegistrar) {
+  registrar.registerTool({
+    name: 'Grep',
+    label: 'Grep',
+    description:
+      'Search for a regex pattern in file contents. Returns matching lines with file path and line number. Use the include parameter to filter by file type.',
+
+    prepareArguments(args) {
+      const input = recordFrom(args);
+      if (!input) return args as GrepArgs;
+      return {
+        ...input,
+        include: stringFrom(input.include) ?? stringFrom(input.glob_filter),
+      } as GrepArgs;
+    },
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const searchPath = resolve(ctx.cwd, params.path ?? '.');
+
+      try {
+        const rgArgs = ['-n', '-H', '--no-heading', '--color=never'];
+        if (params.include) rgArgs.push('--glob', params.include);
+        rgArgs.push('--', params.pattern, searchPath);
+
+        const stdout = await execWithRgFallback(rgArgs, {
+          cwd: ctx.cwd,
+          signal,
+          pattern: params.pattern,
+          searchPath,
+          include: params.include,
+        });
+
+        const lines = stdout.trim().split('\n').filter(Boolean);
+        if (lines.length === 0) {
+          return {
+            content: [{ type: 'text', text: 'No matches found' }],
+            details: { matchCount: 0 },
+          };
+        }
+
+        return {
+          content: [{ type: 'text', text: truncateChars(truncateLines(lines)) }],
+          details: { matchCount: lines.length },
+        };
+      } catch (error: unknown) {
+        return toolError(error, 'Grep', { matchCount: 0 });
+      }
+    },
+    renderCall(args, theme) {
+      const path = args.path ? theme.fg('muted', ` in ${args.path}`) : '';
+      const include = args.include ? theme.fg('dim', ` [${args.include}]`) : '';
+      return text(
+        theme.fg('toolTitle', theme.bold('Grep ')) +
+          theme.fg('accent', `"${args.pattern}"`) +
+          path +
+          include,
+      );
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      const running = renderRunning(isPartial);
+      if (running) return running;
+      const matchCount = numberDetail(result, 'matchCount');
+      return renderResultText(
+        result,
+        expanded,
+        matchCount === 0
+          ? theme.fg('dim', 'No matches')
+          : theme.fg('muted', `${matchCount} match(es)`),
+      );
+    },
+  });
+
+  registrar.registerTool({
+    name: 'Glob',
+    label: 'Glob',
+    description:
+      'Find files matching a glob pattern. Returns a list of matching file paths sorted by modification time (newest first).',
+
+    prepareArguments(args) {
+      const input = recordFrom(args);
+      if (!input) return args as GlobArgs;
+      return {
+        ...input,
+        pattern: stringFrom(input.pattern) ?? stringFrom(input.glob_pattern),
+      } as GlobArgs;
+    },
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const searchPath = resolve(ctx.cwd, params.path ?? '.');
+
+      try {
+        let files: string[];
+
+        if (await hasRipgrep()) {
+          const result = await execFileAsync(
+            'rg',
+            ['--files', '--color=never', '--glob', params.pattern, searchPath],
+            { cwd: ctx.cwd, maxBuffer: MAX_OUTPUT_BYTES, signal },
+          );
+          files = result.stdout.trim().split('\n').filter(Boolean);
+        } else {
+          const normalizedPattern = normalizePath(params.pattern);
+          const matcher = globToRegExp(normalizedPattern);
+          const matchesFile = normalizedPattern.includes('/')
+            ? (file: string) => matcher.test(normalizePath(relative(ctx.cwd, file)))
+            : (file: string) => matcher.test(basename(file));
+          files = (await listFilesRecursive(searchPath, signal)).filter(matchesFile);
+        }
+        files = sortByModifiedNewest(files);
+
+        if (files.length === 0) {
+          return {
+            content: [{ type: 'text', text: 'No files found' }],
+            details: { fileCount: 0 },
+          };
+        }
+
+        return {
+          content: [{ type: 'text', text: truncateChars(truncateLines(files)) }],
+          details: { fileCount: files.length },
+        };
+      } catch (error: unknown) {
+        const err = error as { code?: unknown; stderr?: string };
+        if (err.code === 1 && !err.stderr) {
+          return {
+            content: [{ type: 'text', text: 'No files found' }],
+            details: { fileCount: 0 },
+          };
+        }
+        return toolError(error, 'Glob', { fileCount: 0 });
+      }
+    },
+    renderCall(args, theme) {
+      const path = args.path ? theme.fg('muted', ` in ${args.path}`) : '';
+      return text(
+        theme.fg('toolTitle', theme.bold('Glob ')) + theme.fg('accent', args.pattern) + path,
+      );
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      const running = renderRunning(isPartial);
+      if (running) return running;
+      const fileCount = numberDetail(result, 'fileCount');
+      return renderResultText(
+        result,
+        expanded,
+        fileCount === 0 ? theme.fg('dim', 'No files') : theme.fg('muted', `${fileCount} file(s)`),
+      );
+    },
+  });
+}

package/src/tools/shell.ts

@@ -0,0 +1,142 @@
+// @ts-nocheck
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { promisify } from 'node:util';
+import {
+  detailRecord,
+  MAX_OUTPUT_BYTES,
+  MAX_OUTPUT_CHARS,
+  renderResultText,
+  renderRunning,
+  text,
+} from './rendering.js';
+import type { ToolRegistrar } from './types.js';
+
+const execFileAsync = promisify(execFile);
+
+function shellCommand(command: string): { file: string; args: string[] } | undefined {
+  if (process.platform === 'win32') {
+    if (existsSync('C:\\Windows\\System32\\cmd.exe')) {
+      return { file: 'cmd.exe', args: ['/d', '/s', '/c', command] };
+    }
+    if (existsSync('C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe')) {
+      return {
+        file: 'powershell.exe',
+        args: ['-NoLogo', '-NoProfile', '-Command', command],
+      };
+    }
+    return undefined;
+  }
+
+  if (
+    process.platform !== 'darwin' &&
+    process.platform !== 'linux' &&
+    process.platform !== 'freebsd'
+  ) {
+    return undefined;
+  }
+
+  if (existsSync('/bin/bash')) return { file: '/bin/bash', args: ['-c', command] };
+  if (existsSync('/usr/bin/bash')) return { file: '/usr/bin/bash', args: ['-c', command] };
+  if (existsSync('/bin/sh')) return { file: '/bin/sh', args: ['-c', command] };
+  if (existsSync('/usr/bin/sh')) return { file: '/usr/bin/sh', args: ['-c', command] };
+  return undefined;
+}
+
+export function registerShellTool(registrar: ToolRegistrar) {
+  // ── Shell tool ───────────────────────────────────────────────────────
+
+  registrar.registerTool({
+    name: 'Shell',
+    label: 'Shell',
+    description: 'Execute a shell command and return stdout, stderr, and exit code.',
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const cwd = params.working_directory ? resolve(ctx.cwd, params.working_directory) : ctx.cwd;
+      const timeout = params.timeout ?? 120_000;
+
+      try {
+        const shell = shellCommand(params.command);
+        if (!shell) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: 'Shell error: unsupported platform or shell not found',
+              },
+            ],
+            details: { exitCode: 1, command: params.command },
+          };
+        }
+        const { stdout, stderr } = await execFileAsync(shell.file, shell.args, {
+          cwd,
+          maxBuffer: MAX_OUTPUT_BYTES,
+          timeout,
+          signal,
+        });
+
+        let output = '';
+        if (stdout) output += stdout;
+        if (stderr) output += `\n[stderr]\n${stderr}`;
+
+        if (output.length > MAX_OUTPUT_CHARS) {
+          output = `${output.slice(0, MAX_OUTPUT_CHARS)}\n\n[Output truncated at 50KB]`;
+        }
+
+        return {
+          content: [{ type: 'text', text: output || '(no output)' }],
+          details: { exitCode: 0, command: params.command },
+        };
+      } catch (error: unknown) {
+        const err = error as {
+          code?: unknown;
+          message?: string;
+          signal?: unknown;
+          stdout?: string;
+          stderr?: string;
+        };
+        const exitCode = typeof err.code === 'number' ? err.code : 1;
+
+        let output = '';
+        if (err.stdout) output += err.stdout;
+        if (err.stderr) output += `\n[stderr]\n${err.stderr}`;
+
+        if (output.length > MAX_OUTPUT_CHARS) {
+          output = `${output.slice(0, MAX_OUTPUT_CHARS)}\n\n[Output truncated at 50KB]`;
+        }
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Shell error (exit code ${err.code ?? 'unknown'}): ${err.message ?? 'Unknown error'}${output ? `\n${output}` : ''}`,
+            },
+          ],
+          details: {
+            exitCode,
+            command: params.command,
+            ...(typeof err.signal === 'string' ? { signal: err.signal } : {}),
+          },
+        };
+      }
+    },
+    renderCall(args, theme) {
+      const cwd = args.working_directory ? theme.fg('muted', ` in ${args.working_directory}`) : '';
+      return text(
+        theme.fg('toolTitle', theme.bold('Shell ')) + theme.fg('accent', args.command) + cwd,
+      );
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      const running = renderRunning(isPartial);
+      if (running) return running;
+      const exitCode =
+        typeof detailRecord(result).exitCode === 'number' ? detailRecord(result).exitCode : 1;
+      return renderResultText(
+        result,
+        expanded,
+        exitCode === 0 ? theme.fg('muted', 'Exit 0') : theme.fg('warning', `Exit ${exitCode}`),
+      );
+    },
+  });
+}

package/src/tools/types.ts

@@ -0,0 +1,29 @@
+/** Minimal registrar used to collect Grok/Cursor shim tools. */
+
+export type ToolExecuteContext = { cwd: string };
+
+export type ToolExecuteResult = {
+  content: { type: string; text: string }[];
+  details?: Record<string, unknown>;
+};
+
+export type ShimRegisteredTool = {
+  name: string;
+  description: string;
+  label?: string;
+  prepareArguments?: (params: Record<string, unknown>) => Record<string, unknown>;
+  execute: (
+    toolCallId: string,
+    params: Record<string, unknown>,
+    signal: AbortSignal | undefined,
+    onUpdate: unknown,
+    ctx: ToolExecuteContext,
+  ) => Promise<ToolExecuteResult>;
+  renderCall?: (...args: unknown[]) => { render: (width: number) => string[] };
+  renderResult?: (...args: unknown[]) => { render: (width: number) => string[] };
+};
+
+export type ToolRegistrar = {
+  registerTool: (tool: ShimRegisteredTool) => void;
+  on?: (event: string, handler: unknown) => void;
+};

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid",
+    "types": ["node"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "exclude": ["node_modules", "dist"]
+}