neoctl 0.1.0

package/dist/tools/tool-orchestration.js

@@ -0,0 +1,89 @@
+import { runToolUse } from "./run-tool-use.js";
+export async function runTools(requests, context, options = {}) {
+    let currentContext = context;
+    const messages = [];
+    for (const batch of partitionToolCalls(requests, currentContext)) {
+        if (batch.length === 1 && !batch[0].concurrencySafe) {
+            const updates = await runToolUse(batch[0].request, currentContext, options);
+            const applied = applyUpdates(updates, currentContext);
+            currentContext = applied.context;
+            messages.push(...applied.messages);
+            continue;
+        }
+        const batchResults = await runToolsConcurrently(batch, currentContext, options);
+        for (const item of batch) {
+            const updates = batchResults.get(item.request.id) ?? [];
+            const applied = applyUpdates(updates, currentContext);
+            currentContext = applied.context;
+            messages.push(...applied.messages);
+        }
+    }
+    return { messages, context: currentContext };
+}
+export function partitionToolCalls(requests, context) {
+    const batches = [];
+    let concurrentBatch = [];
+    for (const request of requests) {
+        const tool = context.tools.get(request.name) ?? context.tools.getByAlias?.(request.name);
+        const parsed = {
+            request,
+            tool,
+            concurrencySafe: isConcurrencySafe(tool, request.input, context),
+        };
+        if (parsed.concurrencySafe) {
+            concurrentBatch.push(parsed);
+            continue;
+        }
+        if (concurrentBatch.length) {
+            batches.push(concurrentBatch);
+            concurrentBatch = [];
+        }
+        batches.push([parsed]);
+    }
+    if (concurrentBatch.length)
+        batches.push(concurrentBatch);
+    return batches;
+}
+async function runToolsConcurrently(batch, context, options) {
+    const maxConcurrency = maxToolConcurrency();
+    const results = new Map();
+    let cursor = 0;
+    async function worker() {
+        while (cursor < batch.length) {
+            const item = batch[cursor];
+            cursor += 1;
+            results.set(item.request.id, await runToolUse(item.request, context, options));
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(maxConcurrency, batch.length) }, () => worker()));
+    return results;
+}
+function applyUpdates(updates, context) {
+    let currentContext = context;
+    const messages = [];
+    for (const update of updates) {
+        messages.push(update.message);
+        if (update.context)
+            currentContext = update.context;
+    }
+    return { messages, context: currentContext };
+}
+function isConcurrencySafe(tool, input, context) {
+    if (!tool)
+        return true;
+    if (tool.isConcurrencySafe) {
+        try {
+            return tool.isConcurrencySafe(input, context);
+        }
+        catch {
+            return false;
+        }
+    }
+    return tool.metadata.concurrent;
+}
+function maxToolConcurrency() {
+    const raw = process.env.AGENT_MAX_TOOL_USE_CONCURRENCY ?? process.env.CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY;
+    const parsed = raw ? Number(raw) : 10;
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 10;
+}
+//# sourceMappingURL=tool-orchestration.js.map

package/dist/tools/tool-orchestration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-orchestration.js","sourceRoot":"","sources":["../../src/tools/tool-orchestration.ts"],"names":[],"mappings":"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"}

package/dist/tools/tool.d.ts

@@ -0,0 +1,121 @@
+import type { AppStatePort } from "../app/app-state.js";
+import type { Message, ToolUseRequest } from "../types/messages.js";
+import type { ContentReplacementRecord, ToolResultMemory } from "../session/tool-result-memory.js";
+export interface JsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean;
+    items?: JsonSchema;
+    enum?: unknown[];
+    description?: string;
+    [key: string]: unknown;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: JsonSchema;
+    strict?: boolean;
+}
+export interface ToolMetadata {
+    readOnly: boolean;
+    concurrent: boolean;
+    visible: boolean;
+    requiresApproval?: boolean;
+    destructive?: boolean;
+    shouldDefer?: boolean;
+    alwaysLoad?: boolean;
+    isMcp?: boolean;
+    isLsp?: boolean;
+    maxResultSizeChars?: number;
+    searchHint?: string;
+}
+export interface ToolProgressEvent {
+    toolName: string;
+    toolUseId?: string;
+    message: string;
+    data?: unknown;
+}
+export type ValidationResult<TInput> = {
+    ok: true;
+    value: TInput;
+} | {
+    ok: false;
+    message: string;
+};
+export interface ToolResult {
+    ok: boolean;
+    output: unknown;
+    summary?: string;
+    newMessages?: Message[];
+    contextModifier?: (context: ToolUseContext) => ToolUseContext;
+    mcpMeta?: {
+        meta?: Record<string, unknown>;
+        structuredContent?: Record<string, unknown>;
+    };
+}
+export interface ToolRegistryLike {
+    get(name: string): Tool | undefined;
+    getByAlias?(name: string): Tool | undefined;
+}
+export interface ToolRuntimeOptions {
+    debug?: boolean;
+    verbose?: boolean;
+    mainLoopModel?: string;
+    tools?: ToolRegistryLike;
+    thinkingConfig?: unknown;
+    isNonInteractiveSession?: boolean;
+    refreshTools?: () => Promise<void> | void;
+}
+export interface ToolUseContext {
+    agentId: string;
+    agentType?: string;
+    toolUseId?: string;
+    abortSignal?: AbortSignal;
+    tools: ToolRegistryLike;
+    appState: AppStatePort;
+    messages?: readonly Message[];
+    queryTracking?: unknown;
+    requestPrompt?: string;
+    options?: ToolRuntimeOptions;
+    toolResultMemory?: ToolResultMemory;
+    emit(event: ToolProgressEvent): void;
+    recordContentReplacements?(records: ContentReplacementRecord[]): void;
+    appendSystemMessage?(message: Message): void;
+    setResponseLength?(length: "short" | "medium" | "long"): void;
+    pushApiMetricsEntry?(entry: Record<string, unknown>): void;
+}
+export interface ToolCallOptions<TInput> {
+    canUseTool?: CanUseTool;
+    parentMessage?: Message;
+    onProgress?: (event: ToolProgressEvent) => void;
+}
+export type CanUseTool = (toolUse: ToolUseRequest, context: ToolUseContext) => boolean | ToolPermissionDecision | Promise<boolean | ToolPermissionDecision>;
+export interface ToolPermissionDecision {
+    allowed: boolean;
+    reason?: string;
+}
+export interface Tool<TInput = unknown> {
+    readonly name: string;
+    readonly aliases?: readonly string[];
+    readonly searchHint?: string;
+    readonly description: string | ((input?: TInput, context?: ToolUseContext) => string);
+    readonly inputSchema: JsonSchema;
+    readonly outputSchema?: JsonSchema;
+    readonly metadata: ToolMetadata;
+    validate?(input: unknown, context: ToolUseContext): TInput;
+    validateInput?(input: TInput, context: ToolUseContext): ValidationResult<TInput> | Promise<ValidationResult<TInput>>;
+    isConcurrencySafe?(input: TInput, context: ToolUseContext): boolean;
+    isEnabled?(context?: ToolUseContext): boolean;
+    isReadOnly?(input: TInput, context: ToolUseContext): boolean;
+    isDestructive?(input: TInput, context: ToolUseContext): boolean;
+    interruptBehavior?(input: TInput, context: ToolUseContext): "cancel" | "block";
+    backfillObservableInput?(input: TInput, context: ToolUseContext): unknown;
+    execute?(input: TInput, context: ToolUseContext): Promise<ToolResult>;
+    call?(input: TInput, context: ToolUseContext, options: ToolCallOptions<TInput>): Promise<ToolResult>;
+    mapResult?(result: ToolResult, request: ToolUseRequest): unknown;
+    renderToolUseMessage?(input: TInput): Message | undefined;
+    renderToolResultMessage?(result: ToolResult): Message | undefined;
+    renderToolProgressMessage?(progress: ToolProgressEvent): Message | undefined;
+}
+export declare function resolveToolDescription(tool: Tool, context?: ToolUseContext): string;

package/dist/tools/tool.js

@@ -0,0 +1,4 @@
+export function resolveToolDescription(tool, context) {
+    return typeof tool.description === "function" ? tool.description(undefined, context) : tool.description;
+}
+//# sourceMappingURL=tool.js.map

package/dist/tools/tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.js","sourceRoot":"","sources":["../../src/tools/tool.ts"],"names":[],"mappings":"AAuIA,MAAM,UAAU,sBAAsB,CAAC,IAAU,EAAE,OAAwB;IACzE,OAAO,OAAO,IAAI,CAAC,WAAW,KAAK,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC;AAC1G,CAAC"}

package/dist/types/events.d.ts

@@ -0,0 +1,66 @@
+import type { TerminalReason } from "../core/state.js";
+import type { ModelUsage } from "../model/model-gateway.js";
+import type { Message, ToolUseRequest } from "./messages.js";
+export interface ContextMetrics {
+    model?: string;
+    estimatedInputTokens: number;
+    estimatedChars: number;
+    messageCount: number;
+    toolCount: number;
+    contextWindowTokens?: number;
+    contextWindowSource: "env" | "known" | "unknown";
+    contextUsageRatio?: number;
+    modelMetadata?: {
+        id: string;
+        provider: string;
+        maxOutputTokens?: number;
+        knowledgeCutoff?: string;
+        reasoning?: boolean;
+        imageInput?: boolean;
+        source?: string;
+    };
+}
+export type AgentEvent = {
+    type: "state";
+    phase: string;
+    detail?: string;
+} | {
+    type: "context.metrics";
+    metrics: ContextMetrics;
+} | {
+    type: "assistant.delta";
+    text: string;
+} | {
+    type: "thinking.delta";
+    text: string;
+} | {
+    type: "tool_call.delta";
+    callId: string;
+    name?: string;
+    argumentsDelta: string;
+} | {
+    type: "message";
+    message: Message;
+} | {
+    type: "tool.started";
+    toolUse: ToolUseRequest;
+} | {
+    type: "tool.finished";
+    toolUse: ToolUseRequest;
+    ok: boolean;
+} | {
+    type: "usage";
+    usage: ModelUsage;
+} | {
+    type: "retrying";
+    attempt: number;
+    delayMs: number;
+    error: Error;
+} | {
+    type: "terminal";
+    reason: TerminalReason;
+    detail?: string;
+} | {
+    type: "error";
+    error: Error;
+};

package/dist/types/events.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=events.js.map

package/dist/types/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/types/events.ts"],"names":[],"mappings":""}

package/dist/types/messages.d.ts

@@ -0,0 +1,57 @@
+import type { ModelUsage } from "../model/model-gateway.js";
+export type MessageRole = "system" | "user" | "assistant" | "tool_result" | "progress" | "attachment" | "tombstone";
+export type MessageBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    mimeType: string;
+    data: string;
+    label?: string;
+} | {
+    type: "thinking";
+    text: string;
+    signature?: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: "tool_result";
+    toolUseId: string;
+    name: string;
+    ok: boolean;
+    output: unknown;
+};
+export interface Message {
+    id: string;
+    role: MessageRole;
+    createdAt: string;
+    blocks: MessageBlock[];
+    providerMessageId?: string;
+    requestId?: string;
+    usage?: ModelUsage;
+    isMeta?: boolean;
+    isApiErrorMessage?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface ToolUseRequest {
+    id: string;
+    name: string;
+    input: unknown;
+}
+export interface SystemInitPayload {
+    agentId: string;
+    tools: string[];
+    model?: string;
+    commands?: string[];
+    agents?: string[];
+    skills?: string[];
+    plugins?: string[];
+}
+export declare function createTextMessage(role: MessageRole, text: string): Message;
+export declare function createThinkingMessage(text: string, signature?: string): Message;
+export declare function createToolResultMessage(request: ToolUseRequest, ok: boolean, output: unknown): Message;
+export declare function createTombstoneMessage(reason: string): Message;
+export declare function createSystemInitMessage(payload: SystemInitPayload): Message;

package/dist/types/messages.js

@@ -0,0 +1,42 @@
+export function createTextMessage(role, text) {
+    return {
+        id: cryptoId(),
+        role,
+        createdAt: new Date().toISOString(),
+        blocks: [{ type: "text", text }],
+    };
+}
+export function createThinkingMessage(text, signature) {
+    return {
+        id: cryptoId(),
+        role: "assistant",
+        createdAt: new Date().toISOString(),
+        blocks: [{ type: "thinking", text, signature }],
+    };
+}
+export function createToolResultMessage(request, ok, output) {
+    return {
+        id: cryptoId(),
+        role: "tool_result",
+        createdAt: new Date().toISOString(),
+        blocks: [{ type: "tool_result", toolUseId: request.id, name: request.name, ok, output }],
+    };
+}
+export function createTombstoneMessage(reason) {
+    return {
+        ...createTextMessage("tombstone", reason),
+        isMeta: true,
+        metadata: { tombstone: true },
+    };
+}
+export function createSystemInitMessage(payload) {
+    return {
+        ...createTextMessage("system", `System initialized for ${payload.agentId}`),
+        isMeta: true,
+        metadata: { systemInit: true, ...payload },
+    };
+}
+function cryptoId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+//# sourceMappingURL=messages.js.map

package/dist/types/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.js","sourceRoot":"","sources":["../../src/types/messages.ts"],"names":[],"mappings":"AAwCA,MAAM,UAAU,iBAAiB,CAAC,IAAiB,EAAE,IAAY;IAC/D,OAAO;QACL,EAAE,EAAE,QAAQ,EAAE;QACd,IAAI;QACJ,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACnC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;KACjC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,IAAY,EAAE,SAAkB;IACpE,OAAO;QACL,EAAE,EAAE,QAAQ,EAAE;QACd,IAAI,EAAE,WAAW;QACjB,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACnC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;KAChD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,OAAuB,EAAE,EAAW,EAAE,MAAe;IAC3F,OAAO;QACL,EAAE,EAAE,QAAQ,EAAE;QACd,IAAI,EAAE,aAAa;QACnB,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACnC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC;KACzF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,MAAc;IACnD,OAAO;QACL,GAAG,iBAAiB,CAAC,WAAW,EAAE,MAAM,CAAC;QACzC,MAAM,EAAE,IAAI;QACZ,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE;KAC9B,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,OAA0B;IAChE,OAAO;QACL,GAAG,iBAAiB,CAAC,QAAQ,EAAE,0BAA0B,OAAO,CAAC,OAAO,EAAE,CAAC;QAC3E,MAAM,EAAE,IAAI;QACZ,QAAQ,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE;KAC3C,CAAC;AACJ,CAAC;AAED,SAAS,QAAQ;IACf,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;AACjF,CAAC"}

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name":  "neoctl",
+    "version":  "0.1.0",
+    "description":  "TypeScript scaffold for a streaming agent runtime with a REPL UI layer.",
+    "type":  "module",
+    "engines":  {
+                    "node":  "\u003e=20"
+                },
+    "scripts":  {
+                    "postinstall":  "node scripts/install-ripgrep.cjs --optional",
+                    "vendor:rg":  "node scripts/install-ripgrep.cjs",
+                    "build":  "tsc -p tsconfig.json \u0026\u0026 node scripts/copy-model-metadata.mjs",
+                    "typecheck":  "tsc -p tsconfig.json --noEmit",
+                    "start":  "node dist/repl/index.js",
+                    "dev":  "tsx src/repl/index.ts",
+                    "smoke:core":  "tsx src/core/smoke-core-loop.ts",
+                    "smoke:tools":  "tsx src/tools/smoke-tool-system.ts",
+                    "smoke:context":  "tsx src/context/smoke-context.ts",
+                    "smoke:session":  "tsx src/session/smoke-session.ts",
+                    "smoke:agents":  "tsx src/agents/smoke-agents.ts",
+                    "smoke:skills":  "tsx src/skills/smoke-skills.ts",
+                    "smoke:responses":  "tsx src/model/smoke-responses-mapper.ts",
+                    "smoke:openai":  "tsx src/model/smoke-openai.ts"
+                },
+    "devDependencies":  {
+                            "@types/node":  "^20.12.12",
+                            "tsx":  "^4.19.0",
+                            "typescript":  "^5.5.0"
+                        },
+    "dependencies":  {
+                         "@types/react":  "^19.2.4",
+                         "chalk":  "^5.6.2",
+                         "figures":  "^6.1.0",
+                         "ink":  "^6.8.0",
+                         "marked":  "^18.0.3",
+                         "react":  "^19.2.4",
+                         "shiki":  "^4.0.2",
+                         "strip-ansi":  "^7.2.0",
+                         "wrap-ansi":  "^10.0.0"
+                     },
+    "bin":  {
+                "neo":  "dist/repl/index.js"
+            },
+    "files":  [
+                  "dist",
+                  "scripts",
+                  "README.md"
+              ]
+}

package/scripts/copy-model-metadata.mjs

@@ -0,0 +1,4 @@
+import { mkdirSync, copyFileSync } from "node:fs";
+
+mkdirSync("dist/model", { recursive: true });
+copyFileSync("src/model/model-metadata.json", "dist/model/model-metadata.json");

package/scripts/install-ripgrep.cjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+const fs = require("node:fs");
+const fsp = require("node:fs/promises");
+const os = require("node:os");
+const path = require("node:path");
+const { execFileSync } = require("node:child_process");
+
+const REPO = "BurntSushi/ripgrep";
+const LATEST_RELEASE_URL = `https://api.github.com/repos/${REPO}/releases/latest`;
+const PROJECT_ROOT = path.resolve(__dirname, "..");
+const VENDOR_ROOT = path.join(PROJECT_ROOT, "vendor", "ripgrep");
+const OPTIONAL = process.argv.includes("--optional");
+const FORCE = process.argv.includes("--force");
+
+const TARGETS = {
+  "win32-x64": [/x86_64-pc-windows-msvc\.zip$/i],
+  "win32-arm64": [/aarch64-pc-windows-msvc\.zip$/i],
+  "linux-x64": [/x86_64-unknown-linux-musl\.tar\.gz$/i, /x86_64-unknown-linux-gnu\.tar\.gz$/i],
+  "linux-arm64": [/aarch64-unknown-linux-gnu\.tar\.gz$/i, /aarch64-unknown-linux-musl\.tar\.gz$/i],
+  "darwin-x64": [/x86_64-apple-darwin\.tar\.gz$/i],
+  "darwin-arm64": [/aarch64-apple-darwin\.tar\.gz$/i],
+};
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  if (OPTIONAL) {
+    console.warn(`[ripgrep] optional install skipped: ${message}`);
+    process.exit(0);
+  }
+  console.error(`[ripgrep] install failed: ${message}`);
+  process.exit(1);
+});
+
+async function main() {
+  const key = platformKey();
+  const executable = process.platform === "win32" ? "rg.exe" : "rg";
+  const targetDir = path.join(VENDOR_ROOT, key);
+  const targetPath = path.join(targetDir, executable);
+
+  if (!FORCE && fs.existsSync(targetPath)) {
+    console.log(`[ripgrep] using existing ${path.relative(PROJECT_ROOT, targetPath)}`);
+    return;
+  }
+
+  const release = await getJson(LATEST_RELEASE_URL);
+  const asset = selectAsset(release.assets ?? [], key);
+  if (!asset) throw new Error(`no ripgrep release asset found for ${key}`);
+
+  const tempDir = await fsp.mkdtemp(path.join(os.tmpdir(), "agent-rg-"));
+  try {
+    const archivePath = path.join(tempDir, asset.name);
+    const extractDir = path.join(tempDir, "extract");
+    await fsp.mkdir(extractDir, { recursive: true });
+
+    console.log(`[ripgrep] downloading ${asset.name}`);
+    await download(asset.browser_download_url, archivePath);
+    extractArchive(archivePath, extractDir);
+
+    const binaryPath = await findFile(extractDir, executable);
+    if (!binaryPath) throw new Error(`${executable} not found inside ${asset.name}`);
+
+    await fsp.rm(targetDir, { recursive: true, force: true });
+    await fsp.mkdir(targetDir, { recursive: true });
+    await fsp.copyFile(binaryPath, targetPath);
+    if (process.platform !== "win32") await fsp.chmod(targetPath, 0o755);
+
+    await copyLicenseFiles(extractDir, targetDir);
+    await fsp.writeFile(
+      path.join(targetDir, "manifest.json"),
+      `${JSON.stringify({
+        name: "ripgrep",
+        version: release.tag_name,
+        source: release.html_url,
+        asset: asset.name,
+        installedAt: new Date().toISOString(),
+      }, null, 2)}\n`,
+      "utf8",
+    );
+    console.log(`[ripgrep] installed ${path.relative(PROJECT_ROOT, targetPath)}`);
+  } finally {
+    await fsp.rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+function platformKey() {
+  const key = `${process.platform}-${process.arch}`;
+  if (!TARGETS[key]) throw new Error(`unsupported platform: ${key}`);
+  return key;
+}
+
+function selectAsset(assets, key) {
+  const patterns = TARGETS[key];
+  return assets.find((asset) => patterns.some((pattern) => pattern.test(asset.name)));
+}
+
+async function getJson(url) {
+  const response = await fetch(url, {
+    headers: {
+      Accept: "application/vnd.github+json",
+      "User-Agent": "agent-scaffold-ripgrep-installer",
+    },
+  });
+  if (!response.ok) throw new Error(`GET ${url} returned ${response.status}: ${(await response.text()).slice(0, 200)}`);
+  return response.json();
+}
+
+async function download(url, destination) {
+  const response = await fetch(url, { headers: { "User-Agent": "agent-scaffold-ripgrep-installer" } });
+  if (!response.ok) throw new Error(`download returned ${response.status}`);
+  await fsp.writeFile(destination, Buffer.from(await response.arrayBuffer()));
+}
+
+function extractArchive(archivePath, destination) {
+  try {
+    execFileSync("tar", ["-xf", archivePath, "-C", destination], { stdio: "ignore" });
+    return;
+  } catch (error) {
+    if (process.platform !== "win32" || !archivePath.toLowerCase().endsWith(".zip")) throw error;
+  }
+
+  execFileSync("powershell", [
+    "-NoProfile",
+    "-Command",
+    "Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force",
+    archivePath,
+    destination,
+  ], { stdio: "ignore" });
+}
+
+async function findFile(root, fileName) {
+  const entries = await fsp.readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(root, entry.name);
+    if (entry.isFile() && entry.name === fileName) return fullPath;
+    if (entry.isDirectory()) {
+      const found = await findFile(fullPath, fileName);
+      if (found) return found;
+    }
+  }
+  return undefined;
+}
+
+async function copyLicenseFiles(root, targetDir) {
+  const entries = await fsp.readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(root, entry.name);
+    if (entry.isFile() && /^licen[sc]e|copying|unlicense/i.test(entry.name)) {
+      await fsp.copyFile(fullPath, path.join(targetDir, entry.name));
+    }
+    if (entry.isDirectory()) await copyLicenseFiles(fullPath, targetDir);
+  }
+}