c0de-agent 0.0.0 → 1.0.0

package/dist/dap/session.js

@@ -0,0 +1,130 @@
+import { generateId } from '../shared/index.js';
+import { createDAPClient } from './protocol.js';
+// ── 基于已建立 client 的原子操作（薄封装，对齐 DAP command） ──
+async function dapInitialize(client, adapterID) {
+    return client.request('initialize', {
+        clientID: 'c0de-agent',
+        adapterID,
+        linesStartAt1: true,
+        columnsStartAt1: true,
+        pathFormat: 'path',
+    });
+}
+async function dapLaunch(client, config) {
+    const cmd = config.request === 'attach' ? 'attach' : 'launch';
+    await client.request(cmd, {
+        program: config.program,
+        args: config.args,
+        cwd: config.cwd,
+        stopOnEntry: false,
+        ...config.launchArgs,
+    });
+}
+async function dapSetBreakpoints(client, file, bps) {
+    return client.request('setBreakpoints', {
+        source: { path: file },
+        breakpoints: bps.map((b) => ({ line: b.line, condition: b.condition })),
+    });
+}
+async function dapContinue(client, threadId) {
+    return client.request('continue', { threadId });
+}
+async function dapStep(client, threadId, kind) {
+    const command = kind === 'in' ? 'stepIn' : kind === 'out' ? 'stepOut' : 'next';
+    return client.request(command, { threadId });
+}
+async function dapStackTrace(client, threadId) {
+    const body = (await client.request('stackTrace', { threadId }));
+    return body?.stackFrames ?? [];
+}
+/** 按帧取变量：先 scopes 得到 variablesReference，再 variables 汇总。 */
+async function dapVariables(client, frameId) {
+    const scopesBody = (await client.request('scopes', { frameId }));
+    const refs = scopesBody?.scopes ?? [];
+    const out = [];
+    for (const s of refs) {
+        if (s.variablesReference === undefined)
+            continue;
+        const vBody = (await client.request('variables', {
+            variablesReference: s.variablesReference,
+        }));
+        out.push(...(vBody?.variables ?? []));
+    }
+    return out;
+}
+async function dapEvaluate(client, frameId, expression) {
+    const body = (await client.request('evaluate', { expression, frameId, context: 'repl' }));
+    return body?.result ?? '';
+}
+function createDebugSessionManager() {
+    const sessions = new Map();
+    const require = (sessionId) => {
+        const s = sessions.get(sessionId);
+        if (!s)
+            throw new Error(`DAP session "${sessionId}" not found`);
+        return s;
+    };
+    return {
+        async start(spawn, config) {
+            const transport = spawn(config);
+            const client = createDAPClient(transport);
+            const session = {
+                id: generateId(),
+                adapter: config.adapter,
+                program: config.program,
+                state: 'running',
+            };
+            let lastThread = null;
+            client.on('stopped', (body) => {
+                session.state = 'paused';
+                const tid = body?.threadId;
+                if (typeof tid === 'number')
+                    lastThread = tid;
+            });
+            client.on('terminated', () => {
+                session.state = 'stopped';
+            });
+            await dapInitialize(client, config.adapter);
+            await dapLaunch(client, config);
+            sessions.set(session.id, { session, client, config });
+            return { sessionId: session.id, threadId: lastThread };
+        },
+        setBreakpoint(sessionId, bp) {
+            return dapSetBreakpoints(require(sessionId).client, bp.file, [bp]);
+        },
+        continue(sessionId, threadId) {
+            return dapContinue(require(sessionId).client, threadId);
+        },
+        step(sessionId, threadId, kind) {
+            return dapStep(require(sessionId).client, threadId, kind);
+        },
+        stack(sessionId, threadId) {
+            return dapStackTrace(require(sessionId).client, threadId);
+        },
+        variables(sessionId, frameId) {
+            return dapVariables(require(sessionId).client, frameId);
+        },
+        evaluate(sessionId, frameId, expression) {
+            return dapEvaluate(require(sessionId).client, frameId, expression);
+        },
+        async stop(sessionId) {
+            const s = sessions.get(sessionId);
+            if (!s)
+                return;
+            s.session.state = 'stopped';
+            // disconnect 适配器可能已退出；吞错。
+            try {
+                await s.client.request('disconnect', {});
+            }
+            catch {
+                /* adapter gone */
+            }
+            s.client.dispose();
+            sessions.delete(sessionId);
+        },
+        getSession(sessionId) {
+            return sessions.get(sessionId)?.session;
+        },
+    };
+}
+export { createDebugSessionManager, dapVariables };

package/dist/dap/transport.d.ts

@@ -0,0 +1,8 @@
+import { type ChildProcessWithoutNullStreams } from 'node:child_process';
+import type { DAPTransport } from './protocol.js';
+/** 启动一个调试适配器子进程，将其 stdin/stdout 包装为 DAPTransport。 */
+declare function createProcessTransport(command: string, args?: string[]): {
+    transport: DAPTransport;
+    child: ChildProcessWithoutNullStreams;
+};
+export { createProcessTransport };

package/dist/dap/transport.js

@@ -0,0 +1,30 @@
+import { spawn } from 'node:child_process';
+/** 启动一个调试适配器子进程，将其 stdin/stdout 包装为 DAPTransport。 */
+function createProcessTransport(command, args = []) {
+    const child = spawn(command, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+    const dataHandlers = [];
+    const closeHandlers = [];
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+        for (const h of dataHandlers)
+            h(chunk);
+    });
+    child.on('close', () => {
+        for (const h of closeHandlers)
+            h();
+    });
+    const transport = {
+        write: (chunk) => {
+            if (!child.stdin.destroyed)
+                child.stdin.write(chunk);
+        },
+        onData: (h) => dataHandlers.push(h),
+        onClose: (h) => closeHandlers.push(h),
+        close: () => {
+            if (!child.killed)
+                child.kill();
+        },
+    };
+    return { transport, child };
+}
+export { createProcessTransport };

package/dist/dap/types.d.ts

@@ -0,0 +1,50 @@
+/** 启动调试会话的配置。 */
+type DAPConfig = {
+    /** 调试适配器标识（如 'node', 'python'），用于 initialize.adapterID。 */
+    adapter: string;
+    /** 被调试程序路径。 */
+    program: string;
+    /** attach 或 launch（默认 launch）。 */
+    request?: 'launch' | 'attach';
+    args?: string[];
+    cwd?: string;
+    /** 额外的 launch/attach 参数（适配器特定）。 */
+    launchArgs?: Record<string, unknown>;
+};
+/** 调试会话句柄。 */
+type DAPSession = {
+    id: string;
+    adapter: string;
+    program: string;
+    state: 'running' | 'paused' | 'stopped';
+};
+/** 断点。 */
+type Breakpoint = {
+    file: string;
+    line: number;
+    condition?: string;
+};
+/** 栈帧。 */
+type StackFrame = {
+    id: number;
+    name: string;
+    file: string;
+    line: number;
+    column?: number;
+};
+/** 变量。 */
+type Variable = {
+    name: string;
+    value: string;
+    type?: string;
+    variablesReference?: number;
+};
+/** 工具用的简化配置（spec §21 debug_start 输入）。 */
+type DebugStartInput = {
+    adapter: string;
+    program: string;
+    args?: string[];
+    cwd?: string;
+    stopOnEntry?: boolean;
+};
+export type { Breakpoint, DAPConfig, DAPSession, DebugStartInput, StackFrame, Variable };

package/dist/dap/types.js

@@ -0,0 +1,2 @@
+// DAP 类型（spec §21）。零依赖的最小子集。
+export {};

package/dist/db/client.d.ts

@@ -0,0 +1,22 @@
+import type { PgliteDatabase } from 'drizzle-orm/pglite';
+import * as schema from './schema.js';
+import type { DBConfig } from './types.js';
+/**
+ * Unified database handle.
+ * `db` is the Drizzle ORM instance with schema bound.
+ * `close()` cleans up the connection.
+ */
+type DB = {
+    db: PgliteDatabase<typeof schema>;
+    close(): Promise<void>;
+};
+/**
+ * Create a database connection.
+ *
+ * - PGLite mode: in-process WASM Postgres, no server needed.
+ *   Pass `dataDir` for persistent storage, omit for in-memory (tests).
+ * - PostgreSQL mode: connects to a real PG server via connection string.
+ */
+declare function createDB(config: DBConfig): Promise<DB>;
+export type { DB };
+export { createDB };

package/dist/db/client.js

@@ -0,0 +1,39 @@
+import { drizzle as drizzlePg } from 'drizzle-orm/node-postgres';
+import { drizzle } from 'drizzle-orm/pglite';
+import { Pool } from 'pg';
+import * as schema from './schema.js';
+/**
+ * Create a database connection.
+ *
+ * - PGLite mode: in-process WASM Postgres, no server needed.
+ *   Pass `dataDir` for persistent storage, omit for in-memory (tests).
+ * - PostgreSQL mode: connects to a real PG server via connection string.
+ */
+async function createDB(config) {
+    if (config.driver === 'pglite') {
+        const connection = config.dataDir && config.dataDir !== ':memory:' ? { dataDir: config.dataDir } : undefined;
+        const db = drizzle({ schema, connection });
+        // $client is the underlying PGlite (WASM Postgres) instance drizzle created
+        // from the connection option. Without closing it, each instance leaks
+        // ~100MB+ of WASM memory — which OOM-kills vitest worker forks when many
+        // test files run in the same process.
+        const client = db.$client;
+        return {
+            db,
+            async close() {
+                await client.close();
+            },
+        };
+    }
+    // PostgreSQL mode — cast to PgliteDatabase for a unified interface.
+    // The underlying Drizzle ORM query API is identical across drivers.
+    const pool = new Pool({ connectionString: config.connectionString });
+    const db = drizzlePg(pool, { schema });
+    return {
+        db,
+        async close() {
+            await pool.end();
+        },
+    };
+}
+export { createDB };

package/dist/db/index.d.ts

@@ -0,0 +1,6 @@
+export type { DB } from './client.js';
+export { createDB } from './client.js';
+export { migrateDB } from './migrate.js';
+export type { CompactionArchiveInsert, CompactionArchiveRow, FileSnapshotInsert, FileSnapshotRow, SessionEntryInsert, SessionEntryRow, SessionInsert, SessionRow, } from './schema.js';
+export { compactionArchives, fileSnapshots, sessionEntries, sessions, } from './schema.js';
+export type { DBConfig, DBDriver } from './types.js';

package/dist/db/index.js

@@ -0,0 +1,4 @@
+// DB package: Drizzle schema, PGLite/PostgreSQL client, migrations.
+export { createDB } from './client.js';
+export { migrateDB } from './migrate.js';
+export { compactionArchives, fileSnapshots, sessionEntries, sessions, } from './schema.js';

package/dist/db/migrate.d.ts

@@ -0,0 +1,9 @@
+import type { DB } from './client.js';
+/**
+ * Run all pending database migrations.
+ * Migration SQL files live in `drizzle/` at the project root.
+ *
+ * Must be called after `createDB()` and before any queries.
+ */
+declare function migrateDB(handle: DB): Promise<void>;
+export { migrateDB };

package/dist/db/migrate.js

@@ -0,0 +1,15 @@
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { migrate as drizzleMigrate } from 'drizzle-orm/pglite/migrator';
+/**
+ * Run all pending database migrations.
+ * Migration SQL files live in `drizzle/` at the project root.
+ *
+ * Must be called after `createDB()` and before any queries.
+ */
+async function migrateDB(handle) {
+    const currentDir = fileURLToPath(new URL('.', import.meta.url));
+    const migrationsFolder = resolve(currentDir, '..', '..', 'drizzle');
+    await drizzleMigrate(handle.db, { migrationsFolder });
+}
+export { migrateDB };