toolnet-memory 0.2.0

package/dist/src/embeddings/remote.js

@@ -0,0 +1,76 @@
+export class HuggingFaceEmbeddingProvider {
+    options;
+    name = "huggingface";
+    dimensions = 384;
+    constructor(options) {
+        this.options = options;
+    }
+    async embed(text) {
+        const [vector] = await this.embedMany([text]);
+        return vector;
+    }
+    async embedMany(texts) {
+        if (texts.length === 0) {
+            return [];
+        }
+        const url = `https://router.huggingface.co/hf-inference/models/${this.options.model}/pipeline/feature-extraction`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.options.token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                inputs: texts,
+                options: {
+                    wait_for_model: true,
+                },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`HF embedding failed: ${response.status} ${await response.text()}`);
+        }
+        const data = await response.json();
+        if (!Array.isArray(data)) {
+            throw new Error("HF embedding returned invalid response");
+        }
+        /*
+         * API có thể trả:
+         * [vector]
+         * hoặc [[token vectors]]
+         *
+         * Normalize về sentence vector.
+         */
+        return data.map((item) => normalizeEmbedding(item));
+    }
+}
+function normalizeEmbedding(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("Invalid embedding");
+    }
+    if (value.length > 0 &&
+        typeof value[0] === "number") {
+        return value;
+    }
+    if (value.length > 0 &&
+        Array.isArray(value[0])) {
+        const rows = value;
+        if (rows.length === 0) {
+            return [];
+        }
+        const dimensions = rows[0].length;
+        const output = new Array(dimensions).fill(0);
+        for (const row of rows) {
+            for (let i = 0; i < dimensions; i++) {
+                output[i] +=
+                    row[i] ?? 0;
+            }
+        }
+        for (let i = 0; i < dimensions; i++) {
+            output[i] /=
+                rows.length;
+        }
+        return output;
+    }
+    throw new Error("Unsupported embedding shape");
+}

package/dist/src/embeddings/test-connection.js

@@ -0,0 +1,16 @@
+import "dotenv/config";
+import { createEmbeddingProvider, } from "./embedder.js";
+async function main() {
+    const provider = createEmbeddingProvider();
+    const vector = await provider.embed("ToolNet Memory semantic search");
+    console.log({
+        ok: vector.length > 0,
+        provider: provider.name,
+        dimensions: vector.length,
+        sample: vector.slice(0, 5),
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/hooks/after-edit.js

@@ -0,0 +1,3 @@
+export async function afterEdit(runtime, filePath) {
+    await runtime.fileWrite(filePath);
+}

package/dist/src/hooks/after-tool.js

@@ -0,0 +1,3 @@
+export async function afterTool(runtime, tool, output) {
+    await runtime.afterTool(tool, output);
+}

package/dist/src/hooks/auto-context.js

@@ -0,0 +1,68 @@
+import { getArchitecture } from "../code-intelligence/graph/architecture.js";
+export class AutoContextBuilder {
+    memory;
+    retrieval;
+    graph;
+    constructor(memory, retrieval, graph) {
+        this.memory = memory;
+        this.retrieval = retrieval;
+        this.graph = graph;
+    }
+    build(projectId, query, options = {}) {
+        const maxRules = options.maxRules ?? 3;
+        const maxTodos = options.maxTodos ?? 3;
+        const maxDecisions = options.maxDecisions ?? 3;
+        const maxRelevant = options.maxRelevant ?? 5;
+        const maxCharacters = options.maxCharacters ?? 7000;
+        const rules = this.memory
+            .byType(projectId, "rule")
+            .slice(0, maxRules);
+        const todos = this.memory
+            .byType(projectId, "todo")
+            .slice(0, maxTodos);
+        const decisions = this.memory
+            .byType(projectId, "decision")
+            .slice(0, maxDecisions);
+        const relevant = this.retrieval.search(projectId, query, {
+            topK: maxRelevant,
+        });
+        const architecture = getArchitecture(this.graph, projectId);
+        const blocks = [];
+        blocks.push([
+            "[PROJECT]",
+            `files=${architecture.files}`,
+            `classes=${architecture.classes}`,
+            `functions=${architecture.functions}`,
+            `methods=${architecture.methods}`,
+            `calls=${architecture.calls}`,
+        ].join(" "));
+        for (const item of rules) {
+            blocks.push(`[RULE] ${item.content}`);
+        }
+        for (const item of decisions) {
+            blocks.push(`[DECISION] ${item.content}`);
+        }
+        for (const item of todos) {
+            blocks.push(`[TODO] ${item.content}`);
+        }
+        for (const item of relevant) {
+            const prefix = item.memory.type.toUpperCase();
+            const block = `[${prefix}] ${item.memory.content}`;
+            if (!blocks.includes(block)) {
+                blocks.push(block);
+            }
+        }
+        let output = "";
+        for (const block of blocks) {
+            const next = output.length === 0
+                ? block
+                : `${output}\n${block}`;
+            if (next.length >
+                maxCharacters) {
+                break;
+            }
+            output = next;
+        }
+        return output;
+    }
+}

package/dist/src/hooks/auto-impact-guard.js

@@ -0,0 +1,94 @@
+import { extractEditedFiles, } from "../code-intelligence/impact/edit-tool-detector.js";
+const RISK_ORDER = {
+    LOW: 0,
+    MEDIUM: 1,
+    HIGH: 2,
+    CRITICAL: 3,
+};
+export class AutoImpactGuard {
+    guard;
+    projectId;
+    constructor(guard, projectId) {
+        this.guard = guard;
+        this.projectId = projectId;
+    }
+    async beforeTool(tool, input) {
+        const paths = extractEditedFiles(tool, input);
+        if (paths.length === 0) {
+            return {
+                triggered: false,
+                tool,
+                highestRisk: "LOW",
+                totalRiskScore: 0,
+                files: [],
+                impactedFiles: [],
+                suggestedTests: [],
+                requiresVerification: false,
+                context: "",
+            };
+        }
+        const files = [];
+        for (const filePath of paths) {
+            const result = this.guard.analyzeFile(this.projectId, filePath);
+            files.push({
+                filePath,
+                risk: result.risk,
+                riskScore: result.riskScore,
+                impactedFiles: result.impactedFiles,
+                suggestedTests: result.suggestedTests,
+                impactedCount: result.impacted.length,
+            });
+        }
+        let highestRisk = "LOW";
+        for (const file of files) {
+            if (RISK_ORDER[file.risk] >
+                RISK_ORDER[highestRisk]) {
+                highestRisk =
+                    file.risk;
+            }
+        }
+        const impactedFiles = [
+            ...new Set(files.flatMap((file) => file.impactedFiles)),
+        ];
+        const suggestedTests = [
+            ...new Set(files.flatMap((file) => file.suggestedTests)),
+        ];
+        const totalRiskScore = files.reduce((total, file) => total +
+            file.riskScore, 0);
+        const requiresVerification = highestRisk ===
+            "HIGH" ||
+            highestRisk ===
+                "CRITICAL";
+        const lines = [
+            "[TOOLNET IMPACT GUARD]",
+            `Risk: ${highestRisk}`,
+            `Risk score: ${totalRiskScore}`,
+            `Files being changed: ${paths.join(", ")}`,
+            `Impacted files: ${impactedFiles.length}`,
+        ];
+        if (impactedFiles.length) {
+            lines.push("Blast radius:", ...impactedFiles
+                .slice(0, 20)
+                .map((path) => `- ${path}`));
+        }
+        if (suggestedTests.length) {
+            lines.push("Verify/tests:", ...suggestedTests
+                .slice(0, 15)
+                .map((path) => `- ${path}`));
+        }
+        if (requiresVerification) {
+            lines.push("IMPORTANT: High blast radius. Inspect affected dependencies and run relevant tests after the edit.");
+        }
+        return {
+            triggered: true,
+            tool,
+            highestRisk,
+            totalRiskScore,
+            files,
+            impactedFiles,
+            suggestedTests,
+            requiresVerification,
+            context: lines.join("\n"),
+        };
+    }
+}

package/dist/src/hooks/auto-retrieval.js

@@ -0,0 +1,27 @@
+export class AutoRetrieval {
+    runtime;
+    builder;
+    projectId;
+    constructor(runtime, builder, projectId) {
+        this.runtime = runtime;
+        this.builder = builder;
+        this.projectId = projectId;
+    }
+    async prepare(prompt) {
+        await this.runtime.userPrompt(prompt);
+        const context = this.builder.build(this.projectId, prompt);
+        return {
+            originalPrompt: prompt,
+            context,
+            augmentedPrompt: context
+                ? [
+                    "<toolnet_memory>",
+                    context,
+                    "</toolnet_memory>",
+                    "",
+                    prompt,
+                ].join("\n")
+                : prompt,
+        };
+    }
+}

package/dist/src/hooks/before-agent.js

@@ -0,0 +1,18 @@
+export async function beforeAgent(runtime, contextBuilder, projectId, prompt) {
+    await runtime.userPrompt(prompt);
+    const memoryContext = contextBuilder.build(projectId, prompt);
+    const augmentedPrompt = memoryContext
+        ? [
+            "<toolnet_memory>",
+            memoryContext,
+            "</toolnet_memory>",
+            "",
+            prompt,
+        ].join("\n")
+        : prompt;
+    return {
+        prompt,
+        memoryContext,
+        augmentedPrompt,
+    };
+}

package/dist/src/hooks/before-compact.js

@@ -0,0 +1,3 @@
+export async function beforeCompact(runtime) {
+    await runtime.flush();
+}

package/dist/src/hooks/before-edit.js

@@ -0,0 +1,20 @@
+export async function beforeEdit(impactGuard, projectId, filePath) {
+    const result = impactGuard.analyzeFile(projectId, filePath);
+    /*
+     * Không block cứng AI.
+     * Guard cảnh báo và yêu cầu verify.
+     */
+    return {
+        allowed: true,
+        risk: result.risk,
+        riskScore: result.riskScore,
+        impactedFiles: result.impactedFiles,
+        suggestedTests: result.suggestedTests,
+        warning: result.risk ===
+            "CRITICAL" ||
+            result.risk ===
+                "HIGH"
+            ? `High blast radius: verify ${result.impactedFiles.length} impacted files before finalizing edit.`
+            : undefined,
+    };
+}

package/dist/src/hooks/index.js

@@ -0,0 +1,11 @@
+export * from "./runtime.js";
+export * from "./auto-context.js";
+export * from "./auto-retrieval.js";
+export * from "./session-start.js";
+export * from "./session-end.js";
+export * from "./before-agent.js";
+export * from "./after-tool.js";
+export * from "./after-edit.js";
+export * from "./before-compact.js";
+export * from "./before-edit.js";
+export * from "./auto-impact-guard.js";

package/dist/src/hooks/runtime.js

@@ -0,0 +1,110 @@
+import { ActivityCapture, EventDeduplicator, EventQueue, SessionCapture, } from "../capture/index.js";
+import { MemoryProcessor } from "../processor/memory-processor.js";
+import { deduplicateMemories } from "../memory/deduplicate.js";
+export class HookRuntime {
+    projectId;
+    memory;
+    memoryStore;
+    queue = new EventQueue();
+    capture = new ActivityCapture(this.queue);
+    session = new SessionCapture(this.capture);
+    processor;
+    dedup = new EventDeduplicator();
+    maxEventsBeforeFlush;
+    constructor(options) {
+        this.projectId = options.projectId;
+        this.memory = options.memory;
+        this.memoryStore = options.memoryStore;
+        this.maxEventsBeforeFlush =
+            options.maxEventsBeforeFlush ?? 100;
+        this.processor = new MemoryProcessor(this.memory);
+    }
+    async sessionStart() {
+        this.session.start(this.projectId);
+        await this.flushIfNeeded();
+    }
+    async sessionEnd() {
+        this.session.end(this.projectId);
+        await this.flush();
+    }
+    async userPrompt(content) {
+        this.capture.capture(this.projectId, "user_prompt", { content });
+        await this.flushIfNeeded();
+    }
+    async beforeTool(tool, input) {
+        this.capture.capture(this.projectId, "tool_call", {
+            phase: "before",
+            tool,
+            input,
+        });
+        await this.flushIfNeeded();
+    }
+    async afterTool(tool, output) {
+        this.capture.capture(this.projectId, "tool_call", {
+            phase: "after",
+            tool,
+            output,
+        });
+        await this.flushIfNeeded();
+    }
+    async fileRead(filePath) {
+        this.capture.capture(this.projectId, "file_read", { filePath });
+        await this.flushIfNeeded();
+    }
+    async fileWrite(filePath) {
+        this.capture.capture(this.projectId, "file_write", { filePath });
+        await this.flushIfNeeded();
+    }
+    async command(command, exitCode) {
+        this.capture.capture(this.projectId, "command", {
+            command,
+            exitCode,
+        });
+        await this.flushIfNeeded();
+    }
+    async error(error) {
+        const message = error instanceof Error
+            ? error.message
+            : String(error);
+        this.capture.capture(this.projectId, "error", { message });
+        await this.flushIfNeeded();
+    }
+    async decision(content, metadata = {}) {
+        this.capture.capture(this.projectId, "decision", {
+            content,
+            ...metadata,
+        });
+        await this.flushIfNeeded();
+    }
+    async todo(content, metadata = {}) {
+        this.capture.capture(this.projectId, "todo", {
+            content,
+            ...metadata,
+        });
+        await this.flushIfNeeded();
+    }
+    async flushIfNeeded() {
+        if (this.queue.shouldFlush(this.maxEventsBeforeFlush)) {
+            await this.flush();
+        }
+    }
+    async flush() {
+        const events = this.queue.drain();
+        if (events.length === 0) {
+            return 0;
+        }
+        const uniqueEvents = this.dedup.filter(events);
+        if (uniqueEvents.length === 0) {
+            return 0;
+        }
+        const created = this.processor.process(uniqueEvents);
+        const records = deduplicateMemories(this.memory.exportProject(this.projectId));
+        this.memory.clearProject(this.projectId);
+        this.memory.importRecords(records);
+        await this.memoryStore.save(this.projectId, records);
+        return created;
+    }
+    pendingEvents() {
+        return this.queue.size();
+    }
+}

package/dist/src/hooks/session-end.js

@@ -0,0 +1,3 @@
+export async function onSessionEnd(runtime) {
+    await runtime.sessionEnd();
+}

package/dist/src/hooks/session-start.js

@@ -0,0 +1,3 @@
+export async function onSessionStart(runtime) {
+    await runtime.sessionStart();
+}

package/dist/src/index.js

@@ -0,0 +1,22 @@
+import { createToolNetMemoryRuntime, } from "./runtime/index.js";
+async function main() {
+    const runtime = createToolNetMemoryRuntime();
+    const startup = await runtime.start();
+    const prepared = await runtime.preparePrompt("Tiếp tục công việc hiện tại");
+    console.log({
+        started: true,
+        ...startup,
+        contextCharacters: prepared.context.length,
+    });
+    const shutdown = await runtime.stop();
+    console.log({
+        stopped: true,
+        memories: shutdown.memories,
+        codeParsed: shutdown.code.parsed,
+        vectorsIndexed: shutdown.vectors.indexed,
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/mcp/bootstrap.js

@@ -0,0 +1,68 @@
+import "dotenv/config";
+import { loadConfig, MemoryEngine, ProjectManager, } from "../core/index.js";
+import { RetrievalEngine, } from "../retrieval/retrieval-engine.js";
+import { createEmbeddingProvider, } from "../embeddings/index.js";
+import { CodeGraphStore, ReferenceResolver, SemanticCodeEngine, } from "../code-intelligence/index.js";
+import { createStorageProvider, withStorageRetry, ProjectScopedStorageProvider, MemoryStore, PersistentCodeGraphStore, } from "../storage/index.js";
+import { startMCPServer, } from "./server.js";
+import { ProjectLock, } from "../production/project-lock.js";
+async function main() {
+    const config = loadConfig();
+    const project = new ProjectManager()
+        .detect();
+    const rawStorage = createStorageProvider({
+        provider: config.storage.provider,
+        huggingface: config.storage.huggingface,
+        localRoot: config.storage.localRoot,
+    });
+    const retryStorage = withStorageRetry(rawStorage, {
+        attempts: Number(process.env
+            .TOOLNET_STORAGE_RETRIES ??
+            3),
+    });
+    const storage = new ProjectScopedStorageProvider(retryStorage, project.id, project.name, project.remote ?? project.name);
+    const processLock = new ProjectLock(project.id);
+    await processLock.acquire();
+    const stop = () => {
+        void processLock
+            .release()
+            .finally(() => process.exit(0));
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    const memory = new MemoryEngine();
+    const memoryStore = new MemoryStore(storage);
+    memory.importRecords(await memoryStore.load(project.id));
+    const retrieval = new RetrievalEngine(memory);
+    const graph = new CodeGraphStore();
+    const graphSnapshot = await new PersistentCodeGraphStore(storage).load(project.id);
+    if (graphSnapshot) {
+        graph.import(graphSnapshot.symbols, graphSnapshot.edges);
+    }
+    const references = new ReferenceResolver(graph);
+    const codeSemantic = new SemanticCodeEngine({
+        projectId: project.id,
+        rootPath: project.rootPath,
+        model: process.env
+            .HF_EMBEDDING_MODEL ??
+            "sentence-transformers/all-MiniLM-L6-v2",
+        storage,
+        embeddings: createEmbeddingProvider(),
+        graph,
+    });
+    await codeSemantic.initialize();
+    await startMCPServer({
+        project,
+        memory,
+        retrieval,
+        graph,
+        references,
+        codeSemantic,
+        memoryStore,
+        storage,
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/mcp/context.js

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

package/dist/src/mcp/index.js

@@ -0,0 +1,3 @@
+export * from "./context.js";
+export * from "./server.js";
+export * from "./tools/index.js";

package/dist/src/mcp/server.js

@@ -0,0 +1,45 @@
+import { McpServer, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport, } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { memorySearch, memorySearchSchema, memoryRemember, memoryRememberSchema, memoryForget, memoryForgetSchema, findSymbol, findSymbolSchema, findCallers, findCallersSchema, searchCode, searchCodeSchema, projectContext, projectContextSchema, traceCalls, traceCallsSchema, analyzeImpact, analyzeImpactSchema, getProjectArchitecture, findDependencies, findDependenciesSchema, semanticCodeSearch, semanticCodeSearchSchema, snapshotCreate, snapshotCreateSchema, snapshotList, snapshotRestore, snapshotRestoreSchema, impactGuard, impactGuardSchema, graphDependents, graphDependentsSchema, graphPath, graphPathSchema, graphNeighborhood, graphNeighborhoodSchema, deadCode, deadCodeSchema, } from "./tools/index.js";
+function jsonText(value) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}
+export function createMCPServer(ctx) {
+    const server = new McpServer({
+        name: "toolnet-memory",
+        version: "0.1.0",
+    });
+    server.tool("memory_search", "Search relevant long-term memory for the current project.", memorySearchSchema, async (input) => jsonText(await memorySearch(ctx, input)));
+    server.tool("memory_save", "Save an important memory, decision, rule, TODO or summary.", memoryRememberSchema, async (input) => jsonText(await memoryRemember(ctx, input)));
+    server.tool("memory_forget", "Delete a memory by id.", memoryForgetSchema, async (input) => jsonText(await memoryForget(ctx, input)));
+    server.tool("find_symbol", "Find code symbols by exact name.", findSymbolSchema, async (input) => jsonText(await findSymbol(ctx, input)));
+    server.tool("find_callers", "Find functions or methods calling a symbol.", findCallersSchema, async (input) => jsonText(await findCallers(ctx, input)));
+    server.tool("code_search", "Search indexed code symbols and files.", searchCodeSchema, async (input) => jsonText(await searchCode(ctx, input)));
+    server.tool("project_context", "Get compact project architecture, recent memory and relevant context.", projectContextSchema, async (input) => jsonText(await projectContext(ctx, input)));
+    server.tool("trace_calls", "Trace callers or callees through the code call graph.", traceCallsSchema, async (input) => jsonText(await traceCalls(ctx, input)));
+    server.tool("analyze_impact", "Analyze what code can be affected if a symbol changes.", analyzeImpactSchema, async (input) => jsonText(await analyzeImpact(ctx, input)));
+    server.tool("get_architecture", "Get compact architecture statistics for the indexed project.", {}, async () => jsonText(await getProjectArchitecture(ctx)));
+    server.tool("find_dependencies", "Find direct file dependencies and reverse dependents.", findDependenciesSchema, async (input) => jsonText(await findDependencies(ctx, input)));
+    server.tool("semantic_code_search", "Search source code by semantic meaning, not only exact symbol names.", semanticCodeSearchSchema, async (input) => jsonText(await semanticCodeSearch(ctx, input)));
+    server.tool("snapshot_create", "Create a safe versioned snapshot of project memory, vectors and graph.", snapshotCreateSchema, async (input) => jsonText(await snapshotCreate(ctx, input)));
+    server.tool("snapshot_list", "List available ToolNet Memory snapshots.", {}, async () => jsonText(await snapshotList(ctx)));
+    server.tool("snapshot_restore", "Restore a previous ToolNet Memory snapshot. A safety snapshot is created first.", snapshotRestoreSchema, async (input) => jsonText(await snapshotRestore(ctx, input)));
+    server.tool("impact_guard", "Analyze blast radius before or after code changes. Maps changed files/lines to symbols, follows reverse dependencies, assigns risk and suggests verification targets.", impactGuardSchema, async (input) => jsonText(await impactGuard(ctx, input)));
+    server.tool("graph_dependents", "Find code symbols that depend on a symbol through calls, imports, type usage, writes, inheritance or implementation relationships.", graphDependentsSchema, async (input) => jsonText(await graphDependents(ctx, input)));
+    server.tool("graph_path", "Find the shortest dependency path between two code symbols.", graphPathSchema, async (input) => jsonText(await graphPath(ctx, input)));
+    server.tool("graph_neighborhood", "Explore incoming and outgoing dependency relationships around a code symbol.", graphNeighborhoodSchema, async (input) => jsonText(await graphNeighborhood(ctx, input)));
+    server.tool("dead_code", "Find likely unused code. Results are candidates and must be verified before deletion.", deadCodeSchema, async (input) => jsonText(await deadCode(ctx, input)));
+    return server;
+}
+export async function startMCPServer(ctx) {
+    const server = createMCPServer(ctx);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/src/mcp/tools/analyze-impact.js

@@ -0,0 +1,41 @@
+import { z, } from "zod";
+import { ImpactAnalyzer, } from "../../code-intelligence/impact/impact-analyzer.js";
+export const analyzeImpactSchema = {
+    symbolId: z.string().min(1),
+    depth: z.number()
+        .int()
+        .min(1)
+        .max(10)
+        .optional(),
+};
+export async function analyzeImpact(ctx, input) {
+    const symbol = ctx.graph.getSymbol(input.symbolId);
+    if (!symbol) {
+        return {
+            found: false,
+            impacts: [],
+        };
+    }
+    const analyzer = new ImpactAnalyzer(ctx.graph);
+    const impacts = analyzer.analyze(ctx.project.id, symbol.id, input.depth ?? 4);
+    return {
+        found: true,
+        target: {
+            id: symbol.id,
+            name: symbol.name,
+            qualifiedName: symbol.qualifiedName,
+            filePath: symbol.filePath,
+            type: symbol.type,
+        },
+        impacts: impacts.map((item) => ({
+            id: item.symbol.id,
+            name: item.symbol.name,
+            qualifiedName: item.symbol
+                .qualifiedName,
+            filePath: item.symbol.filePath,
+            type: item.symbol.type,
+            relation: item.relation,
+            depth: item.depth,
+        })),
+    };
+}