c0de-agent 0.0.0 → 1.0.0

package/dist/core/title.js

@@ -0,0 +1,115 @@
+import { chat as defaultChat } from '../llm/provider.js';
+import { updateSessionTitle } from '../session/session.js';
+/** 会话默认占位标题；仍是该值时才有资格自动生成。 */
+const DEFAULT_SESSION_TITLE = 'New Session';
+/** 标题最长字符数，超出截断并加省略号。 */
+const TITLE_MAX_LENGTH = 100;
+/**
+ * 标题生成系统提示。直接移植自 opencode 的 agent/prompt/title.txt（同语义）：
+ * 要求与用户消息同语言、语法自然、聚焦主题、保留技术术语，且对极简输入也
+ * 给出有意义的标题。中文消息 → 中文标题。
+ */
+const TITLE_PROMPT = `You are a title generator. You output ONLY a thread title. Nothing else.
+
+<task>
+Generate a brief title that would help the user find this conversation later.
+
+Follow all rules in <rules>
+Use the <examples> so you know what a good title looks like.
+Your output must be:
+- A single line
+- ≤50 characters
+- No explanations
+</task>
+
+<rules>
+- you MUST use the same language as the user message you are summarizing
+- Title must be grammatically correct and read naturally - no word salad
+- Never include tool names in the title (e.g. "read tool", "bash tool", "edit tool")
+- Focus on the main topic or question the user needs to retrieve
+- Vary your phrasing - avoid repetitive patterns like always starting with "Analyzing"
+- When a file is mentioned, focus on WHAT the user wants to do WITH the file, not just that they shared it
+- Keep exact: technical terms, numbers, filenames, HTTP codes
+- Remove: the, this, my, a, an
+- Never assume tech stack
+- Never use tools
+- NEVER respond to questions, just generate a title for the conversation
+- The title should NEVER include "summarizing" or "generating" when generating a title
+- DO NOT SAY YOU CANNOT GENERATE A TITLE OR COMPLAIN ABOUT THE INPUT
+- Always output something meaningful, even if the input is minimal.
+- If the user message is short or conversational (e.g. "hello", "lol", "what's up", "hey"):
+  → create a title that reflects the user's tone or intent (such as Greeting, Quick check-in, Light chat, Intro message, etc.)
+</rules>
+
+<examples>
+"debug 500 errors in production" → Debugging production 500 errors
+"refactor user service" → Refactoring user service
+"why is app.js failing" → app.js failure investigation
+"implement rate limiting" → Rate limiting implementation
+"how do I connect postgres to my API" → Postgres API connection
+"best practices for React hooks" → React hooks best practices
+"@src/auth.ts can you add refresh token support" → Auth refresh token support
+"@utils/parser.ts this is broken" → Parser bug fix
+"look at @config.json" → Config review
+"@App.tsx add dark mode toggle" → Dark mode toggle in App
+</examples>`;
+/** 解析标题生成用的 (provider, model)：smol 角色优先，否则用传入的实际 chat 模型。 */
+function resolveTitleModel(config, chatProvider, chatModel) {
+    const smol = config.roleRouting?.smol;
+    if (smol)
+        return { provider: smol.provider, model: smol.model };
+    return { provider: chatProvider, model: chatModel };
+}
+/**
+ * 清理模型原始输出为标题：剥除 <think> 标签（推理模型可能输出），取首个非空
+ * trim 行，超长截断加省略号。参考 opencode 的标题清理逻辑。
+ */
+function cleanTitle(raw) {
+    const noThink = raw.replace(/<think>[\s\S]*?<\/think>\s*/g, '');
+    const firstLine = noThink
+        .split('\n')
+        .map((l) => l.trim())
+        .find((l) => l.length > 0) ?? '';
+    if (firstLine.length > TITLE_MAX_LENGTH) {
+        return `${firstLine.slice(0, TITLE_MAX_LENGTH - 3)}...`;
+    }
+    return firstLine;
+}
+/** 会话标题是否仍是默认占位值。 */
+function isDefaultTitle(title) {
+    return title === DEFAULT_SESSION_TITLE;
+}
+/**
+ * 为会话生成标题并持久化。fire-and-forget 语义：任何错误都被吞掉，
+ * 绝不向调用方抛出，绝不覆盖一个已存在的非默认标题。
+ *
+ * @param deps          最小依赖（含可注入的 chatFn）
+ * @param sessionId     目标会话 id
+ * @param firstMessage  第一条用户消息原文
+ * @param chatProvider  会话实际使用的 LLM provider（AgentConfig.provider）
+ * @param chatModel     会话实际使用的 LLM model（AgentConfig.model）
+ */
+async function generateSessionTitle(deps, sessionId, firstMessage, chatProvider, chatModel) {
+    const { db, llmRegistry, config, chatFn = defaultChat } = deps;
+    try {
+        const { provider, model } = resolveTitleModel(config, chatProvider, chatModel);
+        const messages = [
+            { role: 'user', content: `Generate a title for this conversation:\n${firstMessage}` },
+        ];
+        const request = {
+            model,
+            messages,
+            stream: true,
+            system: TITLE_PROMPT,
+        };
+        const text = await chatFn({ registry: llmRegistry }, request, { provider, model });
+        const title = cleanTitle(text);
+        if (title.length === 0)
+            return;
+        await updateSessionTitle(db, sessionId, title);
+    }
+    catch {
+        // 标题生成是尽力而为的辅助功能：失败不阻塞主对话流。
+    }
+}
+export { DEFAULT_SESSION_TITLE, generateSessionTitle, isDefaultTitle };

package/dist/core/tool-exec.d.ts

@@ -0,0 +1,20 @@
+import type { HookRunner } from '../plugins/types.js';
+import type { ToolContext, ToolResult } from '../shared/types/tool.js';
+import type { PermissionChecker, ToolRegistry } from '../tools/types.js';
+type CollectedToolCall = {
+    id: string;
+    tool: string;
+    input: unknown;
+};
+type ToolCallResult = {
+    id: string;
+    result: ToolResult;
+};
+declare function executeToolCall(registry: ToolRegistry, permission: PermissionChecker, ctx: ToolContext, name: string, input: unknown, hookRunner?: HookRunner): Promise<ToolResult>;
+declare function partitionByConflict(calls: CollectedToolCall[]): {
+    parallel: CollectedToolCall[];
+    serial: CollectedToolCall[];
+};
+declare function executeToolCalls(registry: ToolRegistry, permission: PermissionChecker, ctx: ToolContext, calls: CollectedToolCall[], hookRunner?: HookRunner): Promise<ToolCallResult[]>;
+export type { CollectedToolCall, ToolCallResult };
+export { executeToolCall, executeToolCalls, partitionByConflict };

package/dist/core/tool-exec.js

@@ -0,0 +1,64 @@
+import { executeTool } from '../tools/executor.js';
+const WRITE_TOOLS = new Set(['write', 'edit', 'bash']);
+async function executeToolCall(registry, permission, ctx, name, input, hookRunner) {
+    let effectiveInput = input;
+    if (hookRunner) {
+        const hookResult = await hookRunner.runHooks('tool:before', { tool: name, input, ctx });
+        if (hookResult === false) {
+            return { _tag: 'error', error: `Tool "${name}" aborted by hook` };
+        }
+        effectiveInput = hookResult.input;
+    }
+    const result = await executeTool(registry, name, effectiveInput, ctx, permission);
+    if (hookRunner) {
+        await hookRunner.fireHooks('tool:after', { tool: name, input: effectiveInput, result, ctx });
+    }
+    return result;
+}
+function partitionByConflict(calls) {
+    const parallel = [];
+    const serial = [];
+    const writePaths = new Set();
+    for (const tc of calls) {
+        if (WRITE_TOOLS.has(tc.tool)) {
+            const input = tc.input;
+            const path = (input?.path ?? input?.file);
+            if (path && writePaths.has(path)) {
+                serial.push(tc);
+            }
+            else {
+                if (path)
+                    writePaths.add(path);
+                parallel.push(tc);
+            }
+        }
+        else {
+            parallel.push(tc);
+        }
+    }
+    return { parallel, serial };
+}
+async function executeToolCalls(registry, permission, ctx, calls, hookRunner) {
+    const { parallel, serial } = partitionByConflict(calls);
+    const results = [];
+    if (parallel.length > 0) {
+        const settled = await Promise.allSettled(parallel.map(async (tc) => ({
+            id: tc.id,
+            result: await executeToolCall(registry, permission, ctx, tc.tool, tc.input, hookRunner),
+        })));
+        for (const s of settled) {
+            if (s.status === 'fulfilled') {
+                results.push(s.value);
+            }
+            else {
+                results.push({ id: 'unknown', result: { _tag: 'error', error: String(s.reason) } });
+            }
+        }
+    }
+    for (const tc of serial) {
+        const result = await executeToolCall(registry, permission, ctx, tc.tool, tc.input, hookRunner);
+        results.push({ id: tc.id, result });
+    }
+    return results;
+}
+export { executeToolCall, executeToolCalls, partitionByConflict };

package/dist/core/types.d.ts

@@ -0,0 +1,95 @@
+import type { DB } from '../db/client.js';
+import type { chat as ChatFn } from '../llm/provider.js';
+import type { Registry } from '../llm/registry.js';
+import type { HookRunner } from '../plugins/types.js';
+import type { AgentConfig, AgentError, AgentEvent, AgentState, AgentStatus, LLMSegment, PendingToolCall, TokenBudget } from '../shared/types/agent.js';
+import type { ChatTool } from '../shared/types/llm.js';
+import type { DebugTransport, ToolDef, URLRegistry } from '../shared/types/tool.js';
+import type { PermissionChecker, ToolRegistry } from '../tools/types.js';
+import type { AgentRegistry } from './agents/types.js';
+import type { Config } from './config.js';
+/** Runtime services injected into every core function (DI pattern). */
+type AgentDependencies = {
+    db: DB;
+    llmRegistry: Registry;
+    toolRegistry: ToolRegistry;
+    permission: PermissionChecker;
+    config: Config;
+    cwd: string;
+    hookRunner?: HookRunner;
+    /** Optional URL resolver registry wired into tool contexts (spec §3.10). */
+    urlRegistry?: URLRegistry;
+    /** Optional prompt registry for dynamic system-prompt assembly (spec §17).
+     *  When provided, the agent loop renders the prompt from it; otherwise the
+     *  default built-in registry is used. Plugins register sections here. */
+    promptRegistry?: PromptRegistry;
+    /** 可注入的标题生成 chat 实现（测试用）；省略走真实 llm/provider。 */
+    titleChatFn?: typeof ChatFn;
+    /** 可选调试适配器 spawn 钩子（spec §21）：注入后 debug_* 工具可用。
+     *  接收 debug_start 的配置，返回适配器进程的 stdio transport。 */
+    debugSpawn?: (config: unknown) => DebugTransport;
+    /** Agent 类型注册表（spec: multi-agent-design）。注入后 task 工具可按类型派发。 */
+    agentRegistry?: AgentRegistry;
+};
+type ProjectInfo = {
+    name: string;
+    language: string;
+    framework?: string;
+    rootDir: string;
+    gitBranch?: string;
+};
+type PromptContext = {
+    tools: ToolDef[];
+    config: AgentConfig;
+    projectInfo: ProjectInfo;
+    skills?: string[];
+    cwd?: string;
+};
+/** Build context for dynamic prompt assembly (spec §17). */
+type PromptBuildContext = {
+    tools: ToolDef[];
+    config: AgentConfig;
+    projectInfo: ProjectInfo;
+    skills?: string[];
+    agents?: string[];
+    cwd?: string;
+};
+/** A dynamically composable system-prompt section (spec §17). */
+type PromptSection = {
+    id: string;
+    title?: string;
+    /** Static body. Overridden by `render` when present. */
+    content: string;
+    /** Lower priority sorts earlier. */
+    priority: number;
+    /** Omit the section when false. */
+    condition?: (ctx: PromptBuildContext) => boolean;
+    /** Dynamic body; takes precedence over `content`. */
+    render?: (ctx: PromptBuildContext) => string;
+};
+/** Mutable registry of prompt sections, keyed by id (later registration wins). */
+type PromptRegistry = {
+    sections: Map<string, PromptSection>;
+};
+type CommandResult = {
+    _tag: 'success';
+    message: string;
+} | {
+    _tag: 'error';
+    message: string;
+} | {
+    _tag: 'text';
+    text: string;
+};
+type CommandContext = {
+    cwd: string;
+    config: Config;
+    deps: AgentDependencies;
+};
+type SlashCommand = {
+    name: string;
+    description: string;
+    argsHint?: string;
+    execute: (args: string, ctx: CommandContext) => Promise<CommandResult>;
+};
+export type { AgentConfig, AgentDependencies, AgentError, AgentEvent, AgentState, AgentStatus, ChatTool, CommandContext, CommandResult, HookRunner, LLMSegment, PendingToolCall, ProjectInfo, PromptBuildContext, PromptContext, PromptRegistry, PromptSection, SlashCommand, TokenBudget, };

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/worktree.d.ts

@@ -0,0 +1,24 @@
+/** 单仓库 baseline 状态（简化版，不处理嵌套 repo）。 */
+interface RepoBaseline {
+    repoRoot: string;
+    headCommit: string;
+    staged: string;
+    unstaged: string;
+    untracked: string[];
+}
+/** 捕获仓库当前 baseline（HEAD + staged + unstaged + untracked）。 */
+declare function captureBaseline(repoRoot: string): Promise<RepoBaseline>;
+/** 创建隔离 worktree（detached HEAD），返回其路径（子 agent 的 cwd）。 */
+declare function createWorktree(repoRoot: string, branchName: string): Promise<string>;
+/** 计算 worktree 相对 baseline 的完整 diff。
+ *  暂存所有改动（含新文件）后 diff --cached vs HEAD = 含增/删/改的完整 delta。 */
+declare function captureDeltaPatch(worktreeDir: string, _baseline?: RepoBaseline): Promise<string>;
+/** 把 patch 应用回父仓库并自动 commit。返回 commit SHA。 */
+declare function applyPatchToParent(repoRoot: string, patch: string, commitMessage: string): Promise<{
+    commitSha: string;
+    warnings: string[];
+}>;
+/** 清理 worktree（git worktree remove）。 */
+declare function removeWorktree(repoRoot: string, worktreeDir: string): void;
+export type { RepoBaseline };
+export { applyPatchToParent, captureBaseline, captureDeltaPatch, createWorktree, removeWorktree };

package/dist/core/worktree.js

@@ -0,0 +1,68 @@
+import { execFileSync } from 'node:child_process';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+/** 以数组参数执行 git（不经 shell，避免消息含特殊字符被解析）。返回 stdout。 */
+function git(cwd, args) {
+    return execFileSync('git', args, {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+}
+/** 执行 git 并通过 stdin 提供 input（用于 git apply）。 */
+function gitWithInput(cwd, args, input) {
+    return execFileSync('git', args, {
+        cwd,
+        encoding: 'utf-8',
+        input,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+}
+/** 捕获仓库当前 baseline（HEAD + staged + unstaged + untracked）。 */
+async function captureBaseline(repoRoot) {
+    const headCommit = git(repoRoot, ['rev-parse', 'HEAD']);
+    const staged = git(repoRoot, ['diff', '--cached', '--binary']);
+    const unstaged = git(repoRoot, ['diff', '--binary']);
+    const untrackedRaw = git(repoRoot, ['ls-files', '--others', '--exclude-standard']);
+    const untracked = untrackedRaw.split('\n').filter(Boolean);
+    return { repoRoot, headCommit, staged, unstaged, untracked };
+}
+/** 创建隔离 worktree（detached HEAD），返回其路径（子 agent 的 cwd）。 */
+async function createWorktree(repoRoot, branchName) {
+    const wtDir = await mkdtemp(join(tmpdir(), `c0de-wt-${branchName}-`));
+    git(repoRoot, ['worktree', 'add', '--detach', wtDir, 'HEAD']);
+    return wtDir;
+}
+/** 计算 worktree 相对 baseline 的完整 diff。
+ *  暂存所有改动（含新文件）后 diff --cached vs HEAD = 含增/删/改的完整 delta。 */
+async function captureDeltaPatch(worktreeDir, _baseline) {
+    git(worktreeDir, ['add', '-A']);
+    return git(worktreeDir, ['diff', '--cached', '--binary']);
+}
+/** 把 patch 应用回父仓库并自动 commit。返回 commit SHA。 */
+async function applyPatchToParent(repoRoot, patch, commitMessage) {
+    if (!patch.trim()) {
+        return { commitSha: git(repoRoot, ['rev-parse', 'HEAD']), warnings: [] };
+    }
+    try {
+        gitWithInput(repoRoot, ['apply'], patch);
+    }
+    catch {
+        // apply 失败：尝试 3-way 合并
+        gitWithInput(repoRoot, ['apply', '--3way'], patch);
+    }
+    git(repoRoot, ['add', '-A']);
+    git(repoRoot, ['commit', '-m', commitMessage]);
+    return { commitSha: git(repoRoot, ['rev-parse', 'HEAD']), warnings: [] };
+}
+/** 清理 worktree（git worktree remove）。 */
+function removeWorktree(repoRoot, worktreeDir) {
+    try {
+        git(repoRoot, ['worktree', 'remove', '--force', worktreeDir]);
+    }
+    catch {
+        // 清理失败忽略（可能已删）
+    }
+}
+export { applyPatchToParent, captureBaseline, captureDeltaPatch, createWorktree, removeWorktree };

package/dist/dap/index.d.ts

@@ -0,0 +1,6 @@
+export type { DAPClient, DAPMessage, DAPTransport } from './protocol.js';
+export { createDAPClient, createFramer, encodeMessage, } from './protocol.js';
+export type { DebugSessionManager, DebugSpawn } from './session.js';
+export { createDebugSessionManager, dapVariables } from './session.js';
+export { createProcessTransport } from './transport.js';
+export type { Breakpoint, DAPConfig, DAPSession, DebugStartInput, StackFrame, Variable, } from './types.js';

package/dist/dap/index.js

@@ -0,0 +1,4 @@
+// DAP 包（spec §21）：DAP 客户端、会话管理、进程 transport。
+export { createDAPClient, createFramer, encodeMessage, } from './protocol.js';
+export { createDebugSessionManager, dapVariables } from './session.js';
+export { createProcessTransport } from './transport.js';

package/dist/dap/protocol.d.ts

@@ -0,0 +1,40 @@
+/** DAP 传输抽象：包装适配器进程的 stdin/stdout。真实实现见 transport.ts。 */
+type DAPTransport = {
+    write: (chunk: string | Uint8Array) => void;
+    onData: (handler: (chunk: Uint8Array | string) => void) => void;
+    onClose: (handler: () => void) => void;
+    close: () => void;
+};
+type DAPMessage = {
+    seq: number;
+    type: 'request' | 'response' | 'event';
+    command?: string;
+    event?: string;
+    arguments?: unknown;
+    success?: boolean;
+    message?: string;
+    body?: unknown;
+    request_seq?: number;
+};
+/** DAP 客户端：发 request 等 response，收 event。 */
+type DAPClient = {
+    /** 发请求，等对应 seq 的 response；失败 response reject。 */
+    request: (command: string, args?: unknown) => Promise<unknown>;
+    /** 发事件通知（不等响应）。 */
+    notify: (command: string, args?: unknown) => void;
+    /** 订阅 event，返回取消订阅函数。 */
+    on: (event: string, handler: (body: unknown) => void) => () => void;
+    dispose: () => void;
+};
+/** 把一条 JSON 消息编码为 DAP 分帧字节（`Content-Length: N\r\n\r\n{json}`）。 */
+declare function encodeMessage(json: string): string;
+/** 输入流分帧器：喂字节，吐完整 JSON 消息。处理跨 chunk / 粘包。 */
+type Framer = {
+    feed: (chunk: Uint8Array | string) => void;
+    onMessage: (handler: (json: string) => void) => void;
+};
+declare function createFramer(): Framer;
+/** 创建 DAP 客户端。transport 由调用方提供（真实为适配器进程 stdio）。 */
+declare function createDAPClient(transport: DAPTransport): DAPClient;
+export type { DAPClient, DAPMessage, DAPTransport };
+export { createDAPClient, createFramer, encodeMessage };

package/dist/dap/protocol.js

@@ -0,0 +1,132 @@
+// DAP 协议层（spec §21）：JSON-RPC over Content-Length 分帧。
+// 零外部依赖；transport 抽象分离 IO，协议层（编码/分帧/seq 配对）纯逻辑可测。
+/** 把一条 JSON 消息编码为 DAP 分帧字节（`Content-Length: N\r\n\r\n{json}`）。 */
+function encodeMessage(json) {
+    const len = Buffer.byteLength(json, 'utf8');
+    return `Content-Length: ${len}\r\n\r\n${json}`;
+}
+function createFramer() {
+    let buffer = Buffer.alloc(0);
+    const handlers = [];
+    function tryParse() {
+        // 找 header 结束分隔符 \r\n\r\n
+        const sep = buffer.indexOf('\r\n\r\n');
+        if (sep === -1)
+            return;
+        const header = buffer.subarray(0, sep).toString('utf8');
+        const m = /Content-Length:\s*(\d+)/i.exec(header);
+        if (!m) {
+            // 协议错误：丢弃分隔符前内容重试
+            buffer = buffer.subarray(sep + 4);
+            if (buffer.length > 0)
+                tryParse();
+            return;
+        }
+        const len = Number(m[1]);
+        const bodyStart = sep + 4;
+        if (buffer.length < bodyStart + len)
+            return; // body 未到齐
+        const body = buffer.subarray(bodyStart, bodyStart + len).toString('utf8');
+        buffer = buffer.subarray(bodyStart + len);
+        for (const h of handlers)
+            h(body);
+        if (buffer.length > 0)
+            tryParse(); // 粘包：继续解析
+    }
+    return {
+        feed(chunk) {
+            buffer =
+                typeof chunk === 'string'
+                    ? Buffer.concat([buffer, Buffer.from(chunk, 'utf8')])
+                    : Buffer.concat([buffer, chunk]);
+            tryParse();
+        },
+        onMessage(handler) {
+            handlers.push(handler);
+        },
+    };
+}
+/** 创建 DAP 客户端。transport 由调用方提供（真实为适配器进程 stdio）。 */
+function createDAPClient(transport) {
+    let seq = 0;
+    const pending = new Map();
+    const eventHandlers = new Map();
+    const framer = createFramer();
+    let disposed = false;
+    framer.onMessage((json) => {
+        let msg;
+        try {
+            msg = JSON.parse(json);
+        }
+        catch {
+            return;
+        }
+        if (msg.type === 'response') {
+            const p = pending.get(msg.request_seq ?? -1);
+            if (!p)
+                return;
+            pending.delete(msg.request_seq ?? -1);
+            if (msg.success === false) {
+                p.reject(new Error(msg.message || `DAP request ${msg.request_seq} failed`));
+            }
+            else {
+                p.resolve(msg.body);
+            }
+        }
+        else if (msg.type === 'event') {
+            const handlers = eventHandlers.get(msg.event ?? '');
+            if (handlers)
+                for (const h of handlers)
+                    h(msg.body);
+        }
+    });
+    transport.onData((chunk) => framer.feed(chunk));
+    transport.onClose(() => {
+        disposed = true;
+        for (const p of pending.values())
+            p.reject(new Error('DAP transport closed'));
+        pending.clear();
+    });
+    function send(msg) {
+        transport.write(encodeMessage(JSON.stringify(msg)));
+    }
+    return {
+        request(command, args) {
+            if (disposed)
+                return Promise.reject(new Error('DAP client disposed'));
+            seq += 1;
+            const cur = seq;
+            return new Promise((resolve, reject) => {
+                pending.set(cur, { resolve, reject });
+                send({ seq: cur, type: 'request', command, arguments: args });
+            });
+        },
+        notify(command, args) {
+            if (disposed)
+                return;
+            seq += 1;
+            send({ seq, type: 'request', command, arguments: args });
+        },
+        on(event, handler) {
+            let set = eventHandlers.get(event);
+            if (!set) {
+                set = new Set();
+                eventHandlers.set(event, set);
+            }
+            set.add(handler);
+            return () => {
+                set?.delete(handler);
+            };
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            transport.close();
+            for (const p of pending.values())
+                p.reject(new Error('DAP client disposed'));
+            pending.clear();
+        },
+    };
+}
+export { createDAPClient, createFramer, encodeMessage };

package/dist/dap/session.d.ts

@@ -0,0 +1,23 @@
+import { type DAPClient, type DAPTransport } from './protocol.js';
+import type { Breakpoint, DAPConfig, DAPSession, StackFrame, Variable } from './types.js';
+/** spawn 一个调试适配器并返回其 stdio 包装的 transport（由 host 注入）。 */
+type DebugSpawn = (config: DAPConfig) => DAPTransport;
+/** 按帧取变量：先 scopes 得到 variablesReference，再 variables 汇总。 */
+declare function dapVariables(client: DAPClient, frameId: number): Promise<Variable[]>;
+type DebugSessionManager = {
+    start: (spawn: DebugSpawn, config: DAPConfig) => Promise<{
+        sessionId: string;
+        threadId: number | null;
+    }>;
+    setBreakpoint: (sessionId: string, bp: Breakpoint) => Promise<unknown>;
+    continue: (sessionId: string, threadId: number) => Promise<unknown>;
+    step: (sessionId: string, threadId: number, kind: 'over' | 'in' | 'out') => Promise<unknown>;
+    stack: (sessionId: string, threadId: number) => Promise<StackFrame[]>;
+    variables: (sessionId: string, frameId: number) => Promise<Variable[]>;
+    evaluate: (sessionId: string, frameId: number, expression: string) => Promise<string>;
+    stop: (sessionId: string) => Promise<void>;
+    getSession: (sessionId: string) => DAPSession | undefined;
+};
+declare function createDebugSessionManager(): DebugSessionManager;
+export type { DebugSessionManager, DebugSpawn };
+export { createDebugSessionManager, dapVariables };