@zcy2nn/agent-forge 1.0.1

package/dist/interview/dashboard.d.ts

@@ -0,0 +1,62 @@
+import type { InterviewStateEntry } from './types';
+export declare function readDashboardAuthFile(port: number): Promise<{
+    token: string;
+    pid: number;
+    startedAt: number;
+} | null>;
+interface RegisteredSession {
+    sessionID: string;
+    directory: string;
+    pid: number;
+    registeredAt: number;
+}
+export declare const DEFAULT_DASHBOARD_PORT = 43211;
+export interface DashboardConfig {
+    port: number;
+    outputFolder: string;
+    sessionClient?: {
+        list: (params?: Record<string, unknown>) => Promise<{
+            data?: Array<{
+                directory?: string;
+                time?: {
+                    updated?: number;
+                };
+            }>;
+        }>;
+    };
+}
+export declare function createDashboardServer(config: DashboardConfig): {
+    start: () => Promise<string>;
+    close: () => void;
+    registerSession: (info: RegisteredSession) => void;
+    removeSession: (sessionID: string) => void;
+    pushState: (entry: InterviewStateEntry) => void;
+    getState: (interviewId: string) => InterviewStateEntry | undefined;
+    storeAnswers: (interviewId: string, answers: Array<{
+        questionId: string;
+        answer: string;
+    }>) => void;
+    getPendingAnswers: (interviewId: string) => Array<{
+        questionId: string;
+        answer: string;
+    }> | null;
+    consumePendingAnswers: (interviewId: string) => Array<{
+        questionId: string;
+        answer: string;
+    }> | null;
+    consumeNudgeAction: (interviewId: string) => 'more-questions' | 'confirm-complete' | null;
+    authToken: string;
+    discoverSessionDirectories: () => Promise<void>;
+    addManualFolder: (dir: string) => void;
+    removeManualFolder: (dir: string) => void;
+    getManualFolders: () => string[];
+    setScanDays: (days: number) => void;
+    getScanDays: () => number;
+    refreshFiles: () => Promise<void>;
+};
+export declare function probeDashboard(port: number): Promise<{
+    alive: boolean;
+    timestamp: number;
+}>;
+export declare function tryBecomeDashboard(config: DashboardConfig, maxAttempts?: number): Promise<ReturnType<typeof createDashboardServer> | null>;
+export {};

package/dist/interview/document.d.ts

@@ -0,0 +1,25 @@
+import type { InterviewAnswer, InterviewQuestion, InterviewRecord } from './types';
+export declare const DEFAULT_OUTPUT_FOLDER = "interview";
+export declare function normalizeOutputFolder(outputFolder: string): string;
+export declare function createInterviewDirectoryPath(directory: string, outputFolder: string): string;
+export declare function createInterviewFilePath(directory: string, outputFolder: string, idea: string): string;
+export declare function relativeInterviewPath(directory: string, filePath: string): string;
+/**
+ * Resolve a user-provided value to an existing .md file path.
+ * Checks absolute paths, relative paths, and output-folder-relative paths.
+ * Returns null if no matching file is found.
+ */
+export declare function resolveExistingInterviewPath(directory: string, outputFolder: string, value: string): string | null;
+export declare function slugify(value: string): string;
+export declare function extractSummarySection(document: string): string;
+export declare function extractTitle(document: string): string;
+export declare function buildInterviewDocument(idea: string, summary: string, history: string, meta?: {
+    sessionID?: string;
+    baseMessageCount?: number;
+}): string;
+/** Parse frontmatter from a .md file. Returns null if no frontmatter. */
+export declare function parseFrontmatter(content: string): Record<string, string> | null;
+export declare function ensureInterviewFile(record: InterviewRecord): Promise<void>;
+export declare function readInterviewDocument(record: InterviewRecord): Promise<string>;
+export declare function rewriteInterviewDocument(record: InterviewRecord, summary: string): Promise<string>;
+export declare function appendInterviewAnswers(record: InterviewRecord, questions: InterviewQuestion[], answers: InterviewAnswer[]): Promise<void>;

package/dist/interview/helpers.d.ts

@@ -0,0 +1,10 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function sendJson(response: ServerResponse, status: number, value: unknown): void;
+export declare function sendHtml(response: ServerResponse, html: string): void;
+export declare function isValidId(id: string): boolean;
+export declare function extractResumeSlug(interviewId: string): string;
+/**
+ * Read and parse JSON body from an HTTP request with size limit.
+ * Destroys the request if the body exceeds MAX_BODY_SIZE.
+ */
+export declare function readJsonBody(request: IncomingMessage): Promise<unknown>;

package/dist/interview/index.d.ts

@@ -0,0 +1 @@
+export { createInterviewManager } from './manager';

package/dist/interview/manager.d.ts

@@ -0,0 +1,35 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+/**
+ * Interview Manager — Composition root.
+ *
+ * Two modes:
+ *
+ * 1. **Dashboard mode** (dashboard:true or port>0):
+ *    First process to bind the port becomes the dashboard (dumb aggregator).
+ *    Other processes register as sessions and push state to it.
+ *    Sessions drive LLM interaction locally, dashboard just serves the web UI.
+ *
+ * 2. **Per-session mode** (default, port=0, dashboard:false):
+ *    Upstream behavior. Each process runs its own interview server on a random
+ *    port. Lazy startup on first /interview command.
+ */
+export declare function createInterviewManager(ctx: PluginInput, config: PluginConfig): {
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    handleEvent: (input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+};

package/dist/interview/parser.d.ts

@@ -0,0 +1,11 @@
+import type { InterviewAssistantState, InterviewMessage } from './types';
+export declare function flattenMessage(message: InterviewMessage): string;
+export declare function buildFallbackState(messages: InterviewMessage[]): InterviewAssistantState;
+export declare function parseAssistantState(text: string, maxQuestions?: number): {
+    state: InterviewAssistantState | null;
+    error?: string;
+};
+export declare function findLatestAssistantState(messages: InterviewMessage[], maxQuestions?: number): {
+    state: InterviewAssistantState | null;
+    latestAssistantError?: string;
+};

package/dist/interview/prompts.d.ts

@@ -0,0 +1,7 @@
+import type { InterviewQuestion } from './types';
+export declare function buildKickoffPrompt(idea: string, maxQuestions: number): string;
+export declare function buildResumePrompt(document: string, maxQuestions: number): string;
+export declare function buildAnswerPrompt(answers: Array<{
+    questionId: string;
+    answer: string;
+}>, questions: InterviewQuestion[], maxQuestions: number): string;

package/dist/interview/server.d.ts

@@ -0,0 +1,13 @@
+import type { InterviewAnswer, InterviewFileItem, InterviewListItem, InterviewState } from './types';
+export declare function createInterviewServer(deps: {
+    getState: (interviewId: string) => Promise<InterviewState>;
+    listInterviewFiles: () => Promise<InterviewFileItem[]>;
+    listInterviews: () => InterviewListItem[];
+    submitAnswers: (interviewId: string, answers: InterviewAnswer[]) => Promise<void>;
+    handleNudgeAction: (interviewId: string, action: 'more-questions' | 'confirm-complete') => Promise<void>;
+    outputFolder: string;
+    port: number;
+}): {
+    ensureStarted: () => Promise<string>;
+    close: () => void;
+};

package/dist/interview/service.d.ts

@@ -0,0 +1,34 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { InterviewConfig } from '../config';
+import type { InterviewAnswer, InterviewFileItem, InterviewListItem, InterviewRecord, InterviewState } from './types';
+export declare function createInterviewService(ctx: PluginInput, config?: InterviewConfig, deps?: {
+    openBrowser?: (url: string) => void;
+    env?: NodeJS.ProcessEnv;
+}): {
+    setBaseUrlResolver: (resolver: () => Promise<string>) => void;
+    setStatePushCallback: (callback: (interviewId: string, state: InterviewState) => void) => void;
+    setOnInterviewCreated: (callback: (interview: InterviewRecord) => void) => void;
+    getActiveInterviewId: (sessionID: string) => string | null;
+    registerCommand: (config: Record<string, unknown>) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    handleEvent: (input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+    getInterviewState: (interviewId: string) => Promise<InterviewState>;
+    listInterviewFiles: () => Promise<InterviewFileItem[]>;
+    listInterviews: () => InterviewListItem[];
+    submitAnswers: (interviewId: string, answers: InterviewAnswer[]) => Promise<void>;
+    handleNudgeAction: (interviewId: string, action: 'more-questions' | 'confirm-complete') => Promise<void>;
+};

package/dist/interview/types.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+export interface InterviewQuestion {
+    id: string;
+    question: string;
+    options: string[];
+    suggested?: string;
+}
+export interface InterviewAnswer {
+    questionId: string;
+    answer: string;
+}
+export interface InterviewAssistantState {
+    summary: string;
+    title?: string;
+    questions: InterviewQuestion[];
+}
+/** Raw question object from LLM output — loose, everything optional. */
+export declare const RawQuestionSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    question: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    suggested: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/** Raw interview_state block from LLM output. */
+export declare const RawInterviewStateSchema: z.ZodObject<{
+    summary: z.ZodOptional<z.ZodUnknown>;
+    title: z.ZodOptional<z.ZodUnknown>;
+    questions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$strip>;
+export interface InterviewRecord {
+    id: string;
+    sessionID: string;
+    idea: string;
+    markdownPath: string;
+    createdAt: string;
+    status: 'active' | 'abandoned';
+    baseMessageCount: number;
+}
+export interface InterviewMessagePart {
+    type?: string;
+    text?: string;
+}
+export interface InterviewMessage {
+    info?: {
+        role?: string;
+        [key: string]: unknown;
+    };
+    parts?: InterviewMessagePart[];
+}
+export interface InterviewListItem {
+    id: string;
+    idea: string;
+    status: InterviewRecord['status'];
+    createdAt: string;
+}
+export interface InterviewFileItem {
+    fileName: string;
+    resumeCommand: string;
+    title: string;
+    summary: string;
+    sessionID?: string;
+    directory?: string;
+}
+export interface InterviewState {
+    interview: InterviewRecord;
+    url: string;
+    markdownPath: string;
+    mode: 'awaiting-agent' | 'awaiting-user' | 'abandoned' | 'completed' | 'error' | 'session-disconnected';
+    lastParseError?: string;
+    isBusy: boolean;
+    summary: string;
+    questions: InterviewQuestion[];
+    document: string;
+}
+/** Wire format for dashboard state cache entries. */
+export interface InterviewStateEntry {
+    interviewId: string;
+    sessionID: string;
+    idea: string;
+    mode: 'awaiting-agent' | 'awaiting-user' | 'abandoned' | 'completed' | 'error' | 'session-disconnected';
+    summary: string;
+    title: string;
+    questions: Array<{
+        id: string;
+        question: string;
+        options?: string[];
+        suggested?: string;
+    }>;
+    pendingAnswers: Array<{
+        questionId: string;
+        answer: string;
+    }> | null;
+    lastUpdatedAt: number;
+    filePath: string;
+    nudgeAction: 'more-questions' | 'confirm-complete' | null;
+}

package/dist/interview/ui.d.ts

@@ -0,0 +1,12 @@
+import type { InterviewFileItem, InterviewListItem } from './types';
+interface DashboardInterviewItem extends InterviewListItem {
+    url: string;
+    mode: string;
+    resumeSlug: string;
+    sessionID?: string;
+    directory?: string;
+}
+export declare function escapeHtml(value: string): string;
+export declare function renderDashboardPage(interviews: DashboardInterviewItem[], files: InterviewFileItem[], outputFolder: string): string;
+export declare function renderInterviewPage(interviewId: string, resumeSlug: string): string;
+export {};

package/dist/mcp/context7.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * Context7 - official documentation lookup for libraries
+ * @see https://context7.com
+ */
+export declare const context7: RemoteMcpConfig;

package/dist/mcp/grep-app.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * grep.app - ultra-fast code search across GitHub repositories
+ * @see https://grep.app
+ */
+export declare const grep_app: RemoteMcpConfig;

package/dist/mcp/index.d.ts

@@ -0,0 +1,8 @@
+import type { WebsearchConfig } from '../config';
+import type { McpConfig } from './types';
+export type { LocalMcpConfig, McpConfig, RemoteMcpConfig } from './types';
+/**
+ * Creates MCP configurations, excluding disabled ones.
+ * Accepts an optional websearchConfig to override the default Exa provider.
+ */
+export declare function createBuiltinMcps(disabledMcps?: readonly string[], websearchConfig?: WebsearchConfig): Record<string, McpConfig>;

package/dist/mcp/types.d.ts

@@ -0,0 +1,12 @@
+export type RemoteMcpConfig = {
+    type: 'remote';
+    url: string;
+    headers?: Record<string, string>;
+    oauth?: false;
+};
+export type LocalMcpConfig = {
+    type: 'local';
+    command: string[];
+    environment?: Record<string, string>;
+};
+export type McpConfig = RemoteMcpConfig | LocalMcpConfig;

package/dist/mcp/websearch.d.ts

@@ -0,0 +1,9 @@
+import type { WebsearchConfig } from '../config';
+import type { RemoteMcpConfig } from './types';
+/**
+ * Creates a websearch MCP config based on the provided configuration.
+ * Supports Exa (default) and Tavily providers.
+ * @see https://exa.ai  @see https://tavily.com
+ */
+export declare function createWebsearchConfig(config?: WebsearchConfig): RemoteMcpConfig;
+export declare const websearch: RemoteMcpConfig;

package/dist/multiplexer/factory.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Multiplexer factory - creates the appropriate multiplexer instance
+ */
+import type { MultiplexerConfig } from '../config/schema';
+import type { Multiplexer } from './types';
+/**
+ * Create a multiplexer instance based on config.
+ *
+ * Do not cache instances: tmux/zellij integrations may depend on
+ * per-process environment like TMUX_PANE/ZELLIJ, which should be captured
+ * fresh for each plugin context.
+ */
+export declare function getMultiplexer(config: MultiplexerConfig): Multiplexer | null;
+/**
+ * Clear the multiplexer cache (useful for testing)
+ */
+export declare function clearMultiplexerCache(): void;
+/**
+ * Get the effective multiplexer type for auto mode
+ * Returns the actual type that would be used (tmux/zellij/none)
+ */
+export declare function getAutoMultiplexerType(): 'tmux' | 'zellij' | 'none';
+/**
+ * Start background availability check for a multiplexer
+ */
+export declare function startAvailabilityCheck(config: MultiplexerConfig): void;

package/dist/multiplexer/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Multiplexer module exports
+ */
+export { clearMultiplexerCache, getMultiplexer, startAvailabilityCheck, } from './factory';
+export { MultiplexerSessionManager, TmuxSessionManager, } from './session-manager';
+export { TmuxMultiplexer } from './tmux';
+export type { Multiplexer, PaneResult } from './types';
+export { isServerRunning } from './types';
+export { ZellijMultiplexer } from './zellij';

package/dist/multiplexer/session-manager.d.ts

@@ -0,0 +1,53 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { MultiplexerConfig } from '../config/schema';
+interface SessionEvent {
+    type: string;
+    properties?: {
+        info?: {
+            id?: string;
+            parentID?: string;
+            title?: string;
+            directory?: string;
+        };
+        sessionID?: string;
+        status?: {
+            type: string;
+        };
+    };
+}
+/**
+ * Tracks child sessions and spawns/closes multiplexer panes for them.
+ *
+ * Uses session.status events for completion detection instead of polling,
+ * with polling kept as a fallback for reliability.
+ */
+export declare class MultiplexerSessionManager {
+    private client;
+    private serverUrl;
+    private directory;
+    private multiplexer;
+    private sessions;
+    private knownSessions;
+    private spawningSessions;
+    private closingSessions;
+    private pollInterval?;
+    private enabled;
+    constructor(ctx: PluginInput, config: MultiplexerConfig);
+    onSessionCreated(event: SessionEvent): Promise<void>;
+    onSessionStatus(event: SessionEvent): Promise<void>;
+    onSessionDeleted(event: SessionEvent): Promise<void>;
+    private startPolling;
+    private stopPolling;
+    private pollSessions;
+    private closeSession;
+    private respawnIfKnown;
+    private isTrackedOrSpawning;
+    private updatePolling;
+    private getSessionId;
+    cleanup(): Promise<void>;
+}
+/**
+ * @deprecated Use MultiplexerSessionManager instead
+ */
+export declare const TmuxSessionManager: typeof MultiplexerSessionManager;
+export {};

package/dist/multiplexer/tmux/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tmux multiplexer implementation
+ */
+import type { MultiplexerLayout } from '../../config/schema';
+import type { Multiplexer, PaneResult } from '../types';
+export declare class TmuxMultiplexer implements Multiplexer {
+    readonly type: "tmux";
+    private binaryPath;
+    private hasChecked;
+    private storedLayout;
+    private storedMainPaneSize;
+    private targetPane;
+    constructor(layout?: MultiplexerLayout, mainPaneSize?: number);
+    isAvailable(): Promise<boolean>;
+    isInsideSession(): boolean;
+    spawnPane(sessionId: string, description: string, serverUrl: string, directory: string): Promise<PaneResult>;
+    closePane(paneId: string): Promise<boolean>;
+    applyLayout(layout: MultiplexerLayout, mainPaneSize: number): Promise<void>;
+    private getBinary;
+    private targetArgs;
+    private findBinary;
+}

package/dist/multiplexer/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Multiplexer abstraction layer
+ *
+ * Provides a unified interface for terminal multiplexers (tmux, zellij, etc.)
+ * to spawn and manage panes for child agent sessions.
+ */
+import type { MultiplexerConfig, MultiplexerLayout } from '../config/schema';
+export interface PaneResult {
+    success: boolean;
+    paneId?: string;
+}
+/**
+ * Core multiplexer interface
+ * Implementations: TmuxMultiplexer, ZellijMultiplexer
+ */
+export interface Multiplexer {
+    readonly type: 'tmux' | 'zellij';
+    /**
+     * Check if the multiplexer binary is available on the system
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Check if currently running inside a multiplexer session
+     */
+    isInsideSession(): boolean;
+    /**
+     * Spawn a new pane running the given command
+     * @param sessionId - The OpenCode session ID to attach to
+     * @param description - Human-readable description for the pane
+     * @param serverUrl - The OpenCode server URL to attach to
+     * @param directory - The project directory to attach from
+     */
+    spawnPane(sessionId: string, description: string, serverUrl: string, directory: string): Promise<PaneResult>;
+    /**
+     * Close a pane by its ID
+     * @param paneId - The pane ID returned by spawnPane
+     * @returns true if successfully closed
+     */
+    closePane(paneId: string): Promise<boolean>;
+    /**
+     * Apply layout to rebalance panes
+     * @param layout - The layout type to apply
+     * @param mainPaneSize - Percentage for main pane (for main-* layouts)
+     */
+    applyLayout(layout: MultiplexerLayout, mainPaneSize: number): Promise<void>;
+}
+/**
+ * Factory function type for creating multiplexer instances
+ */
+export type MultiplexerFactory = (config: MultiplexerConfig) => Multiplexer;
+/**
+ * Server health check utility (shared across implementations)
+ */
+export declare function isServerRunning(serverUrl: string, timeoutMs?: number, maxAttempts?: number): Promise<boolean>;

package/dist/multiplexer/zellij/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Zellij multiplexer implementation
+ *
+ * Creates a dedicated "opencode-agents" tab for all sub-agent panes.
+ * - First sub-agent uses the default pane from new-tab
+ * - Subsequent sub-agents create new panes
+ * - User stays in their original tab
+ */
+import type { MultiplexerLayout } from '../../config/schema';
+import type { Multiplexer, PaneResult } from '../types';
+export declare class ZellijMultiplexer implements Multiplexer {
+    readonly type: "zellij";
+    private binaryPath;
+    private hasChecked;
+    private agentTabId;
+    private firstPaneId;
+    private firstPaneUsed;
+    constructor(layout?: MultiplexerLayout, mainPaneSize?: number);
+    isAvailable(): Promise<boolean>;
+    isInsideSession(): boolean;
+    spawnPane(sessionId: string, description: string, serverUrl: string, directory: string): Promise<PaneResult>;
+    private createPaneInAgentTab;
+    private runInPane;
+    private ensureAgentTab;
+    private getFirstPaneInTab;
+    private findTabByName;
+    private findTabByNameText;
+    private getCurrentTabId;
+    private listPanes;
+    closePane(paneId: string): Promise<boolean>;
+    applyLayout(_layout: MultiplexerLayout, _mainPaneSize: number): Promise<void>;
+    private getBinary;
+    private findBinary;
+}

package/dist/tools/ast-grep/cli.d.ts

@@ -0,0 +1,15 @@
+import type { CliLanguage, SgResult } from './types';
+export interface RunOptions {
+    pattern: string;
+    lang: CliLanguage;
+    paths?: string[];
+    globs?: string[];
+    rewrite?: string;
+    context?: number;
+    updateAll?: boolean;
+}
+export declare function getAstGrepPath(): Promise<string | null>;
+export declare function startBackgroundInit(): void;
+export declare function runSg(options: RunOptions): Promise<SgResult>;
+export declare function isCliAvailable(): boolean;
+export declare function ensureCliAvailable(): Promise<boolean>;

package/dist/tools/ast-grep/constants.d.ts

@@ -0,0 +1,25 @@
+import { CLI_LANGUAGES } from './types';
+export declare function findSgCliPathSync(): string | null;
+export declare function getSgCliPath(): string;
+export declare function setSgCliPath(path: string): void;
+export { CLI_LANGUAGES };
+export declare const DEFAULT_TIMEOUT_MS = 300000;
+export declare const DEFAULT_MAX_OUTPUT_BYTES: number;
+export declare const DEFAULT_MAX_MATCHES = 500;
+export declare const LANG_EXTENSIONS: Record<string, string[]>;
+export interface EnvironmentCheckResult {
+    cli: {
+        available: boolean;
+        path: string;
+        error?: string;
+    };
+}
+/**
+ * Check if ast-grep CLI is available.
+ * Call this at startup to provide early feedback about missing dependencies.
+ */
+export declare function checkEnvironment(): EnvironmentCheckResult;
+/**
+ * Format environment check result as user-friendly message.
+ */
+export declare function formatEnvironmentCheck(result: EnvironmentCheckResult): string;

package/dist/tools/ast-grep/downloader.d.ts

@@ -0,0 +1,5 @@
+export declare function getCacheDir(): string;
+export declare function getBinaryName(): string;
+export declare function getCachedBinaryPath(): string | null;
+export declare function downloadAstGrep(version?: string): Promise<string | null>;
+export declare function ensureAstGrepBinary(): Promise<string | null>;

package/dist/tools/ast-grep/index.d.ts

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from '@opencode-ai/plugin';
+import { ast_grep_replace, ast_grep_search } from './tools';
+export declare const builtinTools: Record<string, ToolDefinition>;
+export { ensureCliAvailable, getAstGrepPath, isCliAvailable, startBackgroundInit, } from './cli';
+export type { EnvironmentCheckResult } from './constants';
+export { checkEnvironment, formatEnvironmentCheck } from './constants';
+export { ensureAstGrepBinary, getCacheDir, getCachedBinaryPath, } from './downloader';
+export type { CliLanguage, CliMatch, SgResult } from './types';
+export { CLI_LANGUAGES } from './types';
+export { ast_grep_replace, ast_grep_search };

package/dist/tools/ast-grep/tools.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const ast_grep_search: ToolDefinition;
+export declare const ast_grep_replace: ToolDefinition;