@feelingmindful/thinking-graph 1.2.0

package/dist/storage/adapter.js

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

package/dist/storage/memory.d.ts

@@ -0,0 +1,25 @@
+import type { Node, Edge, Session, SkillRegistryEntry, NodeQuery, PaginatedResult, EdgeType, ExportOpts, GraphExport, GraphStats } from '../engine/types.js';
+import type { StorageAdapter } from './adapter.js';
+export declare class InMemoryAdapter implements StorageAdapter {
+    private nodes;
+    private edges;
+    private sessions;
+    private skills;
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    insertNode(node: Node): Promise<void>;
+    getNode(id: string): Promise<Node | null>;
+    queryNodes(query: NodeQuery): Promise<PaginatedResult<Node>>;
+    searchContent(text: string, limit?: number): Promise<Node[]>;
+    insertEdge(edge: Edge): Promise<boolean>;
+    getEdgesFrom(nodeId: string, type?: EdgeType): Promise<Edge[]>;
+    getEdgesTo(nodeId: string, type?: EdgeType): Promise<Edge[]>;
+    traverseEdges(startId: string, type: EdgeType, maxDepth: number): Promise<Node[]>;
+    insertSession(session: Session): Promise<void>;
+    getSession(id: string): Promise<Session | null>;
+    updateSession(id: string, fields: Partial<Session>): Promise<void>;
+    insertSkill(entry: SkillRegistryEntry): Promise<void>;
+    querySkills(filter: Partial<SkillRegistryEntry>): Promise<SkillRegistryEntry[]>;
+    exportAll(opts?: ExportOpts): Promise<GraphExport>;
+    getStats(): Promise<GraphStats>;
+}

package/dist/storage/memory.js

@@ -0,0 +1,171 @@
+export class InMemoryAdapter {
+    nodes = new Map();
+    edges = new Map();
+    sessions = new Map();
+    skills = new Map();
+    async initialize() { }
+    async close() { }
+    // ─── Nodes ─────────────────────────────────────────────
+    async insertNode(node) {
+        this.nodes.set(node.id, { ...node });
+    }
+    async getNode(id) {
+        return this.nodes.get(id) ?? null;
+    }
+    async queryNodes(query) {
+        let results = [...this.nodes.values()];
+        if (query.type) {
+            const types = Array.isArray(query.type) ? query.type : [query.type];
+            results = results.filter(n => types.includes(n.type));
+        }
+        if (query.sessionId) {
+            results = results.filter(n => n.sessionId === query.sessionId);
+        }
+        if (query.projectId && !query.crossProject) {
+            results = results.filter(n => n.projectId === query.projectId);
+        }
+        if (query.since) {
+            results = results.filter(n => n.createdAt >= query.since);
+        }
+        if (query.query) {
+            const q = query.query.toLowerCase();
+            results = results.filter(n => n.content.toLowerCase().includes(q));
+        }
+        // Sort by createdAt desc
+        results.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        const totalCount = results.length;
+        const offset = query.offset ?? 0;
+        const limit = query.limit ?? 20;
+        const items = results.slice(offset, offset + limit);
+        return { items, totalCount, hasMore: offset + limit < totalCount };
+    }
+    async searchContent(text, limit = 20) {
+        const q = text.toLowerCase();
+        return [...this.nodes.values()]
+            .filter(n => n.content.toLowerCase().includes(q))
+            .slice(0, limit);
+    }
+    // ─── Edges ─────────────────────────────────────────────
+    async insertEdge(edge) {
+        // Check for duplicate (same source, target, type)
+        for (const e of this.edges.values()) {
+            if (e.sourceId === edge.sourceId && e.targetId === edge.targetId && e.type === edge.type) {
+                return false;
+            }
+        }
+        this.edges.set(edge.id, { ...edge });
+        return true;
+    }
+    async getEdgesFrom(nodeId, type) {
+        return [...this.edges.values()].filter(e => e.sourceId === nodeId && (!type || e.type === type));
+    }
+    async getEdgesTo(nodeId, type) {
+        return [...this.edges.values()].filter(e => e.targetId === nodeId && (!type || e.type === type));
+    }
+    async traverseEdges(startId, type, maxDepth) {
+        const visited = new Set();
+        const result = [];
+        let frontier = [startId];
+        for (let depth = 0; depth < maxDepth && frontier.length > 0; depth++) {
+            const nextFrontier = [];
+            for (const id of frontier) {
+                if (visited.has(id))
+                    continue;
+                visited.add(id);
+                const edges = await this.getEdgesFrom(id, type);
+                for (const edge of edges) {
+                    if (!visited.has(edge.targetId)) {
+                        const node = await this.getNode(edge.targetId);
+                        if (node) {
+                            result.push(node);
+                            nextFrontier.push(edge.targetId);
+                        }
+                    }
+                }
+            }
+            frontier = nextFrontier;
+        }
+        return result;
+    }
+    // ─── Sessions ──────────────────────────────────────────
+    async insertSession(session) {
+        this.sessions.set(session.id, { ...session });
+    }
+    async getSession(id) {
+        return this.sessions.get(id) ?? null;
+    }
+    async updateSession(id, fields) {
+        const session = this.sessions.get(id);
+        if (session) {
+            this.sessions.set(id, { ...session, ...fields });
+        }
+    }
+    // ─── Skill Registry ───────────────────────────────────
+    async insertSkill(entry) {
+        this.skills.set(entry.id, { ...entry });
+    }
+    async querySkills(filter) {
+        return [...this.skills.values()].filter(s => {
+            if (filter.id && s.id !== filter.id)
+                return false;
+            if (filter.pluginName && s.pluginName !== filter.pluginName)
+                return false;
+            if (filter.skillName && s.skillName !== filter.skillName)
+                return false;
+            if (filter.verb && s.verb !== filter.verb)
+                return false;
+            if (filter.platform && s.platform !== filter.platform && s.platform !== 'all')
+                return false;
+            return true;
+        });
+    }
+    // ─── Export ────────────────────────────────────────────
+    async exportAll(opts) {
+        let nodes = [...this.nodes.values()];
+        let edges = [...this.edges.values()];
+        if (opts?.sessionId) {
+            nodes = nodes.filter(n => n.sessionId === opts.sessionId);
+        }
+        if (opts?.projectId) {
+            nodes = nodes.filter(n => n.projectId === opts.projectId);
+        }
+        if (opts?.type) {
+            const types = Array.isArray(opts.type) ? opts.type : [opts.type];
+            nodes = nodes.filter(n => types.includes(n.type));
+        }
+        const nodeIds = new Set(nodes.map(n => n.id));
+        if (opts?.includeEdges !== false) {
+            edges = edges.filter(e => nodeIds.has(e.sourceId) || nodeIds.has(e.targetId));
+        }
+        else {
+            edges = [];
+        }
+        return {
+            exportedAt: new Date().toISOString(),
+            nodeCount: nodes.length,
+            edgeCount: edges.length,
+            sessions: [...this.sessions.values()],
+            nodes,
+            edges,
+        };
+    }
+    // ─── Stats ─────────────────────────────────────────────
+    async getStats() {
+        const nodesByType = {};
+        for (const n of this.nodes.values()) {
+            nodesByType[n.type] = (nodesByType[n.type] ?? 0) + 1;
+        }
+        const edgesByType = {};
+        for (const e of this.edges.values()) {
+            edgesByType[e.type] = (edgesByType[e.type] ?? 0) + 1;
+        }
+        return {
+            totalNodes: this.nodes.size,
+            totalEdges: this.edges.size,
+            nodesByType,
+            edgesByType,
+            techDebtCount: nodesByType['tech_debt'] ?? 0,
+            principleViolations: edgesByType['violates'] ?? 0,
+        };
+    }
+}

package/dist/storage/sqlite.d.ts

@@ -0,0 +1,30 @@
+import type { Node, Edge, Session, SkillRegistryEntry, NodeQuery, PaginatedResult, EdgeType, ExportOpts, GraphExport, GraphStats } from '../engine/types.js';
+import type { StorageAdapter } from './adapter.js';
+export interface SQLiteAdapterOpts {
+    dbPath: string;
+}
+export declare class SQLiteAdapter implements StorageAdapter {
+    private db;
+    private dbPath;
+    constructor(opts: SQLiteAdapterOpts);
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    insertNode(node: Node): Promise<void>;
+    getNode(id: string): Promise<Node | null>;
+    queryNodes(query: NodeQuery): Promise<PaginatedResult<Node>>;
+    searchContent(text: string, limit?: number): Promise<Node[]>;
+    insertEdge(edge: Edge): Promise<boolean>;
+    getEdgesFrom(nodeId: string, type?: EdgeType): Promise<Edge[]>;
+    getEdgesTo(nodeId: string, type?: EdgeType): Promise<Edge[]>;
+    traverseEdges(startId: string, type: EdgeType, maxDepth: number): Promise<Node[]>;
+    insertSession(session: Session): Promise<void>;
+    getSession(id: string): Promise<Session | null>;
+    updateSession(id: string, fields: Partial<Session>): Promise<void>;
+    insertSkill(entry: SkillRegistryEntry): Promise<void>;
+    querySkills(filter: Partial<SkillRegistryEntry>): Promise<SkillRegistryEntry[]>;
+    exportAll(opts?: ExportOpts): Promise<GraphExport>;
+    getStats(): Promise<GraphStats>;
+    private rowToNode;
+    private rowToEdge;
+    private rowToSession;
+}

package/dist/storage/sqlite.js

@@ -0,0 +1,310 @@
+import Database from 'better-sqlite3';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { mkdirSync } from 'fs';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MIGRATION_PATH = join(__dirname, '../../migrations/001-initial.sql');
+export class SQLiteAdapter {
+    db;
+    dbPath;
+    constructor(opts) {
+        this.dbPath = opts.dbPath;
+    }
+    async initialize() {
+        // Ensure parent directory exists
+        const dir = dirname(this.dbPath);
+        mkdirSync(dir, { recursive: true });
+        this.db = new Database(this.dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        // Run migration
+        const sql = readFileSync(MIGRATION_PATH, 'utf-8');
+        this.db.exec(sql);
+    }
+    async close() {
+        this.db.close();
+    }
+    // ─── Nodes ─────────────────────────────────────────────
+    async insertNode(node) {
+        this.db.prepare(`
+      INSERT INTO nodes (id, type, content, session_id, project_id, metadata,
+        created_at, updated_at, thought_number, total_thoughts, branch_id,
+        is_revision, revises_thought)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(node.id, node.type, node.content, node.sessionId, node.projectId ?? null, JSON.stringify(node.metadata), node.createdAt, node.updatedAt, node.thoughtNumber ?? null, node.totalThoughts ?? null, node.branchId ?? null, node.isRevision ? 1 : 0, node.revisesThought ?? null);
+    }
+    async getNode(id) {
+        const row = this.db.prepare('SELECT * FROM nodes WHERE id = ?').get(id);
+        return row ? this.rowToNode(row) : null;
+    }
+    async queryNodes(query) {
+        const conditions = [];
+        const params = [];
+        if (query.type) {
+            const types = Array.isArray(query.type) ? query.type : [query.type];
+            conditions.push(`type IN (${types.map(() => '?').join(',')})`);
+            params.push(...types);
+        }
+        if (query.sessionId) {
+            conditions.push('session_id = ?');
+            params.push(query.sessionId);
+        }
+        if (query.projectId && !query.crossProject) {
+            conditions.push('project_id = ?');
+            params.push(query.projectId);
+        }
+        if (query.since) {
+            conditions.push('created_at >= ?');
+            params.push(query.since);
+        }
+        if (query.query) {
+            // Use FTS for text search
+            conditions.push('rowid IN (SELECT rowid FROM nodes_fts WHERE nodes_fts MATCH ?)');
+            params.push(query.query);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const countRow = this.db.prepare(`SELECT COUNT(*) as cnt FROM nodes ${where}`).get(...params);
+        const totalCount = countRow.cnt;
+        const limit = query.limit ?? 20;
+        const offset = query.offset ?? 0;
+        const rows = this.db.prepare(`SELECT * FROM nodes ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+        return {
+            items: rows.map(r => this.rowToNode(r)),
+            totalCount,
+            hasMore: offset + limit < totalCount,
+        };
+    }
+    async searchContent(text, limit = 20) {
+        const rows = this.db.prepare(`
+      SELECT n.* FROM nodes_fts fts
+      JOIN nodes n ON n.rowid = fts.rowid
+      WHERE nodes_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `).all(text, limit);
+        return rows.map(r => this.rowToNode(r));
+    }
+    // ─── Edges ─────────────────────────────────────────────
+    async insertEdge(edge) {
+        try {
+            this.db.prepare(`
+        INSERT INTO edges (id, source_id, target_id, type, weight, reasoning, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(edge.id, edge.sourceId, edge.targetId, edge.type, edge.weight, edge.reasoning ?? null, edge.createdAt);
+            return true;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes('UNIQUE constraint')) {
+                return false;
+            }
+            throw err;
+        }
+    }
+    async getEdgesFrom(nodeId, type) {
+        const sql = type
+            ? 'SELECT * FROM edges WHERE source_id = ? AND type = ?'
+            : 'SELECT * FROM edges WHERE source_id = ?';
+        const params = type ? [nodeId, type] : [nodeId];
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.rowToEdge(r));
+    }
+    async getEdgesTo(nodeId, type) {
+        const sql = type
+            ? 'SELECT * FROM edges WHERE target_id = ? AND type = ?'
+            : 'SELECT * FROM edges WHERE target_id = ?';
+        const params = type ? [nodeId, type] : [nodeId];
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => this.rowToEdge(r));
+    }
+    async traverseEdges(startId, type, maxDepth) {
+        const rows = this.db.prepare(`
+      WITH RECURSIVE chain(id, depth) AS (
+        SELECT target_id, 1
+        FROM edges
+        WHERE source_id = ? AND type = ?
+        UNION ALL
+        SELECT e.target_id, c.depth + 1
+        FROM edges e
+        JOIN chain c ON e.source_id = c.id
+        WHERE e.type = ? AND c.depth < ?
+      )
+      SELECT DISTINCT n.* FROM nodes n
+      JOIN chain c ON n.id = c.id
+      ORDER BY c.depth
+    `).all(startId, type, type, maxDepth);
+        return rows.map(r => this.rowToNode(r));
+    }
+    // ─── Sessions ──────────────────────────────────────────
+    async insertSession(session) {
+        this.db.prepare(`
+      INSERT INTO sessions (id, project_id, project_path, description, started_at, last_active)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(session.id, session.projectId ?? null, session.projectPath ?? null, session.description ?? null, session.startedAt, session.lastActiveAt);
+    }
+    async getSession(id) {
+        const row = this.db.prepare('SELECT * FROM sessions WHERE id = ?').get(id);
+        return row ? this.rowToSession(row) : null;
+    }
+    async updateSession(id, fields) {
+        const sets = [];
+        const params = [];
+        if (fields.lastActiveAt !== undefined) {
+            sets.push('last_active = ?');
+            params.push(fields.lastActiveAt);
+        }
+        if (fields.description !== undefined) {
+            sets.push('description = ?');
+            params.push(fields.description);
+        }
+        if (sets.length > 0) {
+            params.push(id);
+            this.db.prepare(`UPDATE sessions SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+        }
+    }
+    // ─── Skill Registry ───────────────────────────────────
+    async insertSkill(entry) {
+        this.db.prepare(`
+      INSERT OR IGNORE INTO skill_registry
+        (id, plugin_name, skill_name, verb, invocation, areas, detects, produces, invokes, platform)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(entry.id, entry.pluginName, entry.skillName, entry.verb ?? null, entry.invocation, JSON.stringify(entry.areas), JSON.stringify(entry.detects), JSON.stringify(entry.produces), JSON.stringify(entry.invokes), entry.platform ?? null);
+    }
+    async querySkills(filter) {
+        const conditions = [];
+        const params = [];
+        if (filter.id) {
+            conditions.push('id = ?');
+            params.push(filter.id);
+        }
+        if (filter.pluginName) {
+            conditions.push('plugin_name = ?');
+            params.push(filter.pluginName);
+        }
+        if (filter.skillName) {
+            conditions.push('skill_name = ?');
+            params.push(filter.skillName);
+        }
+        if (filter.verb) {
+            conditions.push('verb = ?');
+            params.push(filter.verb);
+        }
+        if (filter.platform) {
+            conditions.push("(platform = ? OR platform = 'all')");
+            params.push(filter.platform);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const rows = this.db.prepare(`SELECT * FROM skill_registry ${where}`).all(...params);
+        return rows.map(r => ({
+            id: r.id,
+            pluginName: r.plugin_name,
+            skillName: r.skill_name,
+            verb: r.verb,
+            invocation: r.invocation,
+            areas: JSON.parse(r.areas),
+            detects: JSON.parse(r.detects),
+            produces: JSON.parse(r.produces),
+            invokes: JSON.parse(r.invokes),
+            platform: r.platform,
+        }));
+    }
+    // ─── Export ────────────────────────────────────────────
+    async exportAll(opts) {
+        const conditions = [];
+        const params = [];
+        if (opts?.sessionId) {
+            conditions.push('session_id = ?');
+            params.push(opts.sessionId);
+        }
+        if (opts?.projectId) {
+            conditions.push('project_id = ?');
+            params.push(opts.projectId);
+        }
+        if (opts?.type) {
+            const types = Array.isArray(opts.type) ? opts.type : [opts.type];
+            conditions.push(`type IN (${types.map(() => '?').join(',')})`);
+            params.push(...types);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const nodeRows = this.db.prepare(`SELECT * FROM nodes ${where}`).all(...params);
+        const nodes = nodeRows.map(r => this.rowToNode(r));
+        let edges = [];
+        if (opts?.includeEdges !== false) {
+            const nodeIds = nodes.map(n => n.id);
+            if (nodeIds.length > 0) {
+                const placeholders = nodeIds.map(() => '?').join(',');
+                const edgeRows = this.db.prepare(`SELECT * FROM edges WHERE source_id IN (${placeholders}) OR target_id IN (${placeholders})`).all(...nodeIds, ...nodeIds);
+                edges = edgeRows.map(r => this.rowToEdge(r));
+            }
+        }
+        const sessionRows = this.db.prepare('SELECT * FROM sessions').all();
+        return {
+            exportedAt: new Date().toISOString(),
+            nodeCount: nodes.length,
+            edgeCount: edges.length,
+            sessions: sessionRows.map(r => this.rowToSession(r)),
+            nodes,
+            edges,
+        };
+    }
+    // ─── Stats ─────────────────────────────────────────────
+    async getStats() {
+        const nodesByType = {};
+        const ntRows = this.db.prepare('SELECT type, COUNT(*) as cnt FROM nodes GROUP BY type').all();
+        for (const r of ntRows)
+            nodesByType[r.type] = r.cnt;
+        const edgesByType = {};
+        const etRows = this.db.prepare('SELECT type, COUNT(*) as cnt FROM edges GROUP BY type').all();
+        for (const r of etRows)
+            edgesByType[r.type] = r.cnt;
+        const totalNodes = this.db.prepare('SELECT COUNT(*) as cnt FROM nodes').get().cnt;
+        const totalEdges = this.db.prepare('SELECT COUNT(*) as cnt FROM edges').get().cnt;
+        return {
+            totalNodes,
+            totalEdges,
+            nodesByType,
+            edgesByType,
+            techDebtCount: nodesByType['tech_debt'] ?? 0,
+            principleViolations: edgesByType['violates'] ?? 0,
+        };
+    }
+    // ─── Row mappers ───────────────────────────────────────
+    rowToNode(row) {
+        return {
+            id: row.id,
+            type: row.type,
+            content: row.content,
+            sessionId: row.session_id,
+            projectId: row.project_id,
+            metadata: JSON.parse(row.metadata || '{}'),
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            thoughtNumber: row.thought_number,
+            totalThoughts: row.total_thoughts,
+            branchId: row.branch_id,
+            isRevision: row.is_revision === 1,
+            revisesThought: row.revises_thought,
+        };
+    }
+    rowToEdge(row) {
+        return {
+            id: row.id,
+            sourceId: row.source_id,
+            targetId: row.target_id,
+            type: row.type,
+            weight: row.weight,
+            reasoning: row.reasoning,
+            createdAt: row.created_at,
+        };
+    }
+    rowToSession(row) {
+        return {
+            id: row.id,
+            projectId: row.project_id,
+            projectPath: row.project_path,
+            description: row.description,
+            startedAt: row.started_at,
+            lastActiveAt: row.last_active,
+        };
+    }
+}

package/dist/tools/export.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import type { ThinkingGraph } from '../engine/graph.js';
+export declare const exportSchema: z.ZodObject<{
+    format: z.ZodEnum<["json", "summary"]>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>, z.ZodArray<z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>, "many">]>>;
+    includeEdges: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    outputPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    format: "json" | "summary";
+    includeEdges: boolean;
+    type?: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research" | ("thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research")[] | undefined;
+    sessionId?: string | undefined;
+    projectId?: string | undefined;
+    outputPath?: string | undefined;
+}, {
+    format: "json" | "summary";
+    type?: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research" | ("thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research")[] | undefined;
+    sessionId?: string | undefined;
+    projectId?: string | undefined;
+    includeEdges?: boolean | undefined;
+    outputPath?: string | undefined;
+}>;
+export type ExportInput = z.infer<typeof exportSchema>;
+export declare function exportHandler(graph: ThinkingGraph, input: ExportInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/export.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { writeFileSync } from 'fs';
+import { NODE_TYPES } from '../engine/types.js';
+export const exportSchema = z.object({
+    format: z.enum(['json', 'summary']).describe('Output format'),
+    sessionId: z.string().optional(),
+    projectId: z.string().optional(),
+    type: z.union([z.enum(NODE_TYPES), z.array(z.enum(NODE_TYPES))]).optional(),
+    includeEdges: z.boolean().optional().default(true),
+    outputPath: z.string().optional().describe('Write to file'),
+});
+export async function exportHandler(graph, input) {
+    if (input.format === 'summary') {
+        const summary = await graph.exportSummary({
+            format: 'summary',
+            sessionId: input.sessionId,
+            projectId: input.projectId,
+            type: input.type,
+        });
+        if (input.outputPath) {
+            writeFileSync(input.outputPath, summary, 'utf-8');
+        }
+        return {
+            content: [{ type: 'text', text: summary }],
+        };
+    }
+    // JSON format
+    const data = await graph.exportGraph({
+        format: 'json',
+        sessionId: input.sessionId,
+        projectId: input.projectId,
+        type: input.type,
+        includeEdges: input.includeEdges,
+    });
+    const json = JSON.stringify(data, null, 2);
+    if (input.outputPath) {
+        writeFileSync(input.outputPath, json, 'utf-8');
+    }
+    return {
+        content: [{ type: 'text', text: json }],
+    };
+}