toolnet-memory 0.2.0

package/dist/src/mcp/tools/dead-code.js

@@ -0,0 +1,55 @@
+import { z, } from "zod";
+import { DeadCodeAnalyzer, } from "../../code-intelligence/analysis/dead-code-analyzer.js";
+export const deadCodeSchema = {
+    confidence: z.enum([
+        "high",
+        "medium",
+        "low",
+        "all",
+    ])
+        .optional(),
+    filePath: z.string()
+        .min(1)
+        .optional(),
+    limit: z.number()
+        .int()
+        .min(1)
+        .max(500)
+        .optional(),
+};
+const RANK = {
+    high: 3,
+    medium: 2,
+    low: 1,
+};
+export async function deadCode(ctx, input) {
+    const analyzer = new DeadCodeAnalyzer(ctx.graph);
+    let result = analyzer.analyze(ctx.project.id);
+    if (input.confidence &&
+        input.confidence !==
+            "all") {
+        const minimum = RANK[input.confidence];
+        result =
+            result.filter((item) => RANK[item.confidence] >= minimum);
+    }
+    if (input.filePath) {
+        result =
+            result.filter((item) => item.filePath ===
+                input.filePath);
+    }
+    const total = result.length;
+    const limit = input.limit ??
+        100;
+    return {
+        total,
+        high: result.filter((item) => item.confidence ===
+            "high").length,
+        medium: result.filter((item) => item.confidence ===
+            "medium").length,
+        low: result.filter((item) => item.confidence ===
+            "low").length,
+        warning: "Dead-code results are candidates only. Verify before deleting code.",
+        candidates: result
+            .slice(0, limit),
+    };
+}

package/dist/src/mcp/tools/find-callers.js

@@ -0,0 +1,24 @@
+import { z, } from "zod";
+import { GraphQueryEngine, } from "../../code-intelligence/query/graph-query-engine.js";
+import { compactSymbol, resolveGraphSymbol, } from "./graph-query-utils.js";
+export const findCallersSchema = {
+    symbolId: z.string().min(1),
+};
+export async function findCallers(ctx, input) {
+    const symbol = resolveGraphSymbol(ctx, input.symbolId);
+    if (!symbol) {
+        return {
+            found: false,
+            query: input.symbolId,
+            callers: [],
+        };
+    }
+    const query = new GraphQueryEngine(ctx.graph);
+    const callers = query.callers(ctx.project.id, symbol.id);
+    return {
+        found: true,
+        symbol: compactSymbol(symbol),
+        count: callers.length,
+        callers: callers.map(compactSymbol),
+    };
+}

package/dist/src/mcp/tools/find-dependencies.js

@@ -0,0 +1,57 @@
+import { z, } from "zod";
+import { DependencyAnalyzer, } from "../../code-intelligence/analysis/dependency-analyzer.js";
+export const findDependenciesSchema = {
+    filePath: z.string().min(1),
+    direction: z.enum([
+        "dependencies",
+        "dependents",
+        "both",
+    ])
+        .optional(),
+};
+export async function findDependencies(ctx, input) {
+    const analyzer = new DependencyAnalyzer(ctx.graph);
+    const record = analyzer
+        .analyze(ctx.project.id)
+        .find((item) => item.filePath ===
+        input.filePath);
+    if (!record) {
+        return {
+            found: false,
+            filePath: input.filePath,
+            dependencies: [],
+            dependents: [],
+        };
+    }
+    const fileSymbols = ctx.graph
+        .allSymbols(ctx.project.id)
+        .filter((symbol) => symbol.type === "file");
+    const fileByPath = new Map(fileSymbols.map((symbol) => [
+        symbol.filePath,
+        symbol,
+    ]));
+    const formatFile = (filePath) => {
+        const symbol = fileByPath.get(filePath);
+        return {
+            id: symbol?.id ??
+                filePath,
+            filePath,
+        };
+    };
+    const direction = input.direction ??
+        "both";
+    return {
+        found: true,
+        filePath: record.filePath,
+        outgoingEdges: record.outgoingEdges,
+        incomingEdges: record.incomingEdges,
+        dependencies: direction ===
+            "dependents"
+            ? []
+            : record.dependencies.map(formatFile),
+        dependents: direction ===
+            "dependencies"
+            ? []
+            : record.dependents.map(formatFile),
+    };
+}

package/dist/src/mcp/tools/find-symbol.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const findSymbolSchema = {
+    name: z.string().min(1),
+};
+export async function findSymbol(ctx, input) {
+    return ctx.graph.findByName(ctx.project.id, input.name);
+}

package/dist/src/mcp/tools/get-architecture.js

@@ -0,0 +1,11 @@
+import { getArchitecture, } from "../../code-intelligence/graph/architecture.js";
+export async function getProjectArchitecture(ctx) {
+    return {
+        project: {
+            id: ctx.project.id,
+            name: ctx.project.name,
+            rootPath: ctx.project.rootPath,
+        },
+        architecture: getArchitecture(ctx.graph, ctx.project.id),
+    };
+}

package/dist/src/mcp/tools/graph-dependents.js

@@ -0,0 +1,24 @@
+import { z, } from "zod";
+import { GraphQueryEngine, } from "../../code-intelligence/query/graph-query-engine.js";
+import { compactSymbol, resolveGraphSymbol, } from "./graph-query-utils.js";
+export const graphDependentsSchema = {
+    symbol: z.string().min(1),
+};
+export async function graphDependents(ctx, input) {
+    const target = resolveGraphSymbol(ctx, input.symbol);
+    if (!target) {
+        return {
+            found: false,
+            query: input.symbol,
+            dependents: [],
+        };
+    }
+    const query = new GraphQueryEngine(ctx.graph);
+    const dependents = query.dependents(ctx.project.id, target.id);
+    return {
+        found: true,
+        symbol: compactSymbol(target),
+        count: dependents.length,
+        dependents: dependents.map(compactSymbol),
+    };
+}

package/dist/src/mcp/tools/graph-neighborhood.js

@@ -0,0 +1,58 @@
+import { z, } from "zod";
+import { GraphQueryEngine, } from "../../code-intelligence/query/graph-query-engine.js";
+import { compactSymbol, resolveGraphSymbol, } from "./graph-query-utils.js";
+export const graphNeighborhoodSchema = {
+    symbol: z.string().min(1),
+    depth: z.number()
+        .int()
+        .min(1)
+        .max(5)
+        .optional(),
+    limit: z.number()
+        .int()
+        .min(1)
+        .max(200)
+        .optional(),
+};
+export async function graphNeighborhood(ctx, input) {
+    const symbol = resolveGraphSymbol(ctx, input.symbol);
+    if (!symbol) {
+        return {
+            found: false,
+            query: input.symbol,
+        };
+    }
+    const query = new GraphQueryEngine(ctx.graph);
+    const result = query.neighborhood(ctx.project.id, symbol.id, input.depth ??
+        1);
+    if (!result) {
+        return {
+            found: false,
+            query: input.symbol,
+        };
+    }
+    const limit = input.limit ??
+        50;
+    return {
+        found: true,
+        center: compactSymbol(result.center),
+        incomingCount: result.incoming.length,
+        outgoingCount: result.outgoing.length,
+        incoming: result.incoming
+            .slice(0, limit)
+            .map((item) => ({
+            depth: item.depth,
+            via: item.via
+                ?.type,
+            symbol: compactSymbol(item.symbol),
+        })),
+        outgoing: result.outgoing
+            .slice(0, limit)
+            .map((item) => ({
+            depth: item.depth,
+            via: item.via
+                ?.type,
+            symbol: compactSymbol(item.symbol),
+        })),
+    };
+}

package/dist/src/mcp/tools/graph-path.js

@@ -0,0 +1,43 @@
+import { z, } from "zod";
+import { GraphQueryEngine, } from "../../code-intelligence/query/graph-query-engine.js";
+import { compactSymbol, resolveGraphSymbol, } from "./graph-query-utils.js";
+export const graphPathSchema = {
+    from: z.string().min(1),
+    to: z.string().min(1),
+    maxDepth: z.number()
+        .int()
+        .min(1)
+        .max(30)
+        .optional(),
+};
+export async function graphPath(ctx, input) {
+    const from = resolveGraphSymbol(ctx, input.from);
+    const to = resolveGraphSymbol(ctx, input.to);
+    if (!from ||
+        !to) {
+        return {
+            found: false,
+            fromFound: Boolean(from),
+            toFound: Boolean(to),
+            path: [],
+            edges: [],
+        };
+    }
+    const query = new GraphQueryEngine(ctx.graph);
+    const result = query.shortestPath(ctx.project.id, from.id, to.id, input.maxDepth ??
+        12);
+    return {
+        found: result.found,
+        distance: result.distance,
+        from: compactSymbol(from),
+        to: compactSymbol(to),
+        path: result.symbols.map(compactSymbol),
+        edges: result.edges.map((edge) => ({
+            id: edge.id,
+            type: edge.type,
+            from: edge.from,
+            to: edge.to,
+            metadata: edge.metadata,
+        })),
+    };
+}

package/dist/src/mcp/tools/graph-query-utils.js

@@ -0,0 +1,32 @@
+import { GraphQueryEngine, } from "../../code-intelligence/query/graph-query-engine.js";
+export function resolveGraphSymbol(ctx, value) {
+    const direct = ctx.graph.getSymbol(value);
+    if (direct &&
+        direct.projectId ===
+            ctx.project.id) {
+        return direct;
+    }
+    const query = new GraphQueryEngine(ctx.graph);
+    const exact = query
+        .findSymbols(ctx.project.id, value)
+        .find((symbol) => symbol.name ===
+        value ||
+        symbol.qualifiedName ===
+            value);
+    if (exact) {
+        return exact;
+    }
+    return (query.findSymbols(ctx.project.id, value)[0] ??
+        null);
+}
+export function compactSymbol(symbol) {
+    return {
+        id: symbol.id,
+        name: symbol.name,
+        qualifiedName: symbol.qualifiedName,
+        type: symbol.type,
+        filePath: symbol.filePath,
+        startLine: symbol.startLine,
+        endLine: symbol.endLine,
+    };
+}

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

@@ -0,0 +1,34 @@
+import { z, } from "zod";
+import { ImpactGuard, } from "../../code-intelligence/impact/impact-guard.js";
+export const impactGuardSchema = {
+    mode: z.enum([
+        "git_diff",
+        "file",
+    ])
+        .optional(),
+    filePath: z.string()
+        .optional(),
+    depth: z.number()
+        .int()
+        .min(1)
+        .max(10)
+        .optional(),
+};
+export async function impactGuard(ctx, input) {
+    const guard = new ImpactGuard(ctx.graph);
+    const mode = input.mode ??
+        (input.filePath
+            ? "file"
+            : "git_diff");
+    if (mode === "file") {
+        if (!input.filePath) {
+            throw new Error("filePath is required when mode=file");
+        }
+        return guard.analyzeFile(ctx.project.id, input.filePath, {
+            maxDepth: input.depth,
+        });
+    }
+    return guard.analyzeGitDiff(ctx.project.id, ctx.project.rootPath, {
+        maxDepth: input.depth,
+    });
+}

package/dist/src/mcp/tools/index-repository.js

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

package/dist/src/mcp/tools/index.js

@@ -0,0 +1,20 @@
+export * from "./memory-search.js";
+export * from "./memory-remember.js";
+export * from "./memory-forget.js";
+export * from "./find-symbol.js";
+export * from "./find-callers.js";
+export * from "./search-code.js";
+export * from "./project-context.js";
+export * from "./snapshot-create.js";
+export * from "./snapshot-list.js";
+export * from "./snapshot-restore.js";
+export * from "./trace-calls.js";
+export * from "./analyze-impact.js";
+export * from "./get-architecture.js";
+export * from "./find-dependencies.js";
+export * from "./semantic-code-search.js";
+export * from "./impact-guard.js";
+export * from "./graph-dependents.js";
+export * from "./graph-path.js";
+export * from "./graph-neighborhood.js";
+export * from "./dead-code.js";

package/dist/src/mcp/tools/memory-decisions.js

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

package/dist/src/mcp/tools/memory-forget.js

@@ -0,0 +1,14 @@
+import { z, } from "zod";
+export const memoryForgetSchema = {
+    id: z.string().min(1),
+};
+export async function memoryForget(ctx, input) {
+    const deleted = ctx.memory.delete(input.id);
+    if (deleted &&
+        ctx.memoryStore) {
+        await ctx.memoryStore.save(ctx.project.id, ctx.memory.exportProject(ctx.project.id));
+    }
+    return {
+        deleted,
+    };
+}

package/dist/src/mcp/tools/memory-recent.js

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

package/dist/src/mcp/tools/memory-remember.js

@@ -0,0 +1,33 @@
+import { z, } from "zod";
+export const memoryRememberSchema = {
+    type: z.enum([
+        "activity",
+        "decision",
+        "rule",
+        "todo",
+        "summary",
+    ]),
+    content: z.string()
+        .min(1),
+    tags: z.array(z.string()).optional(),
+    importance: z.enum([
+        "critical",
+        "high",
+        "normal",
+        "temporary",
+    ]).optional(),
+};
+export async function memoryRemember(ctx, input) {
+    const record = ctx.memory.remember({
+        projectId: ctx.project.id,
+        type: input.type,
+        content: input.content,
+        tags: input.tags,
+        importance: input.importance,
+        source: "mcp",
+    });
+    if (ctx.memoryStore) {
+        await ctx.memoryStore.save(ctx.project.id, ctx.memory.exportProject(ctx.project.id));
+    }
+    return record;
+}

package/dist/src/mcp/tools/memory-rules.js

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

package/dist/src/mcp/tools/memory-search.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export const memorySearchSchema = {
+    query: z.string(),
+    limit: z.number().int().min(1).max(20).optional(),
+};
+export async function memorySearch(ctx, input) {
+    const results = ctx.retrieval.search(ctx.project.id, input.query, {
+        topK: input.limit ?? 8,
+    });
+    return results.map((result) => ({
+        id: result.memory.id,
+        type: result.memory.type,
+        content: result.memory.content,
+        importance: result.memory.importance,
+        score: result.score,
+        tags: result.memory.tags,
+    }));
+}

package/dist/src/mcp/tools/memory-todos.js

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

package/dist/src/mcp/tools/project-context.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { getArchitecture } from "../../code-intelligence/graph/architecture.js";
+export const projectContextSchema = {
+    query: z.string().optional(),
+    memoryLimit: z.number().int().min(1).max(20).optional(),
+};
+export async function projectContext(ctx, input) {
+    const architecture = getArchitecture(ctx.graph, ctx.project.id);
+    const recent = ctx.memory.recent(ctx.project.id, 5);
+    const relevant = input.query
+        ? ctx.retrieval.search(ctx.project.id, input.query, {
+            topK: input.memoryLimit ?? 5,
+        })
+        : [];
+    return {
+        project: {
+            id: ctx.project.id,
+            name: ctx.project.name,
+            rootPath: ctx.project.rootPath,
+        },
+        architecture,
+        recent,
+        relevant: relevant.map((item) => item.memory),
+    };
+}

package/dist/src/mcp/tools/search-code.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export const searchCodeSchema = {
+    query: z.string().min(1),
+    limit: z.number().int().min(1).max(50).optional(),
+};
+export async function searchCode(ctx, input) {
+    const q = input.query.toLowerCase();
+    const limit = input.limit ?? 20;
+    return ctx.graph
+        .allSymbols(ctx.project.id)
+        .filter((symbol) => symbol.name
+        .toLowerCase()
+        .includes(q) ||
+        symbol.qualifiedName
+            ?.toLowerCase()
+            .includes(q) ||
+        symbol.filePath
+            .toLowerCase()
+            .includes(q))
+        .slice(0, limit);
+}

package/dist/src/mcp/tools/semantic-code-search.js

@@ -0,0 +1,33 @@
+import { z, } from "zod";
+export const semanticCodeSearchSchema = {
+    query: z.string().min(1),
+    limit: z.number()
+        .int()
+        .min(1)
+        .max(20)
+        .optional(),
+};
+export async function semanticCodeSearch(ctx, input) {
+    if (!ctx.codeSemantic) {
+        return {
+            available: false,
+            results: [],
+        };
+    }
+    const results = await ctx.codeSemantic.search(input.query, input.limit ?? 8);
+    return {
+        available: true,
+        results: results.map((result) => ({
+            id: result.chunk.id,
+            filePath: result.chunk.filePath,
+            symbol: result.chunk.symbolName,
+            symbolType: result.chunk.symbolType,
+            startLine: result.chunk.startLine,
+            endLine: result.chunk.endLine,
+            score: result.score,
+            vectorScore: result.vectorScore,
+            lexicalScore: result.lexicalScore,
+            content: result.chunk.content,
+        })),
+    };
+}

package/dist/src/mcp/tools/snapshot-create.js

@@ -0,0 +1,13 @@
+import { z, } from "zod";
+import { SnapshotManager, } from "../../snapshot/index.js";
+export const snapshotCreateSchema = {
+    reason: z.string()
+        .optional(),
+};
+export async function snapshotCreate(ctx, input) {
+    if (!ctx.storage) {
+        throw new Error("Storage unavailable");
+    }
+    return new SnapshotManager(ctx.storage).create(ctx.project.id, input.reason ??
+        "manual-mcp");
+}

package/dist/src/mcp/tools/snapshot-list.js

@@ -0,0 +1,7 @@
+import { SnapshotManager, } from "../../snapshot/index.js";
+export async function snapshotList(ctx) {
+    if (!ctx.storage) {
+        throw new Error("Storage unavailable");
+    }
+    return new SnapshotManager(ctx.storage).list(ctx.project.id);
+}

package/dist/src/mcp/tools/snapshot-restore.js

@@ -0,0 +1,13 @@
+import { z, } from "zod";
+import { SnapshotManager, } from "../../snapshot/index.js";
+export const snapshotRestoreSchema = {
+    snapshotId: z.string().min(1),
+};
+export async function snapshotRestore(ctx, input) {
+    if (!ctx.storage) {
+        throw new Error("Storage unavailable");
+    }
+    const manager = new SnapshotManager(ctx.storage);
+    await manager.create(ctx.project.id, "before-rollback");
+    return manager.restore(ctx.project.id, input.snapshotId);
+}

package/dist/src/mcp/tools/trace-calls.js

@@ -0,0 +1,37 @@
+import { z, } from "zod";
+import { CallGraphTracer, } from "../../code-intelligence/graph/trace.js";
+export const traceCallsSchema = {
+    symbolId: z.string().min(1),
+    direction: z.enum([
+        "callers",
+        "callees",
+    ])
+        .optional(),
+    depth: z.number()
+        .int()
+        .min(1)
+        .max(10)
+        .optional(),
+};
+export async function traceCalls(ctx, input) {
+    const tracer = new CallGraphTracer(ctx.graph);
+    const direction = input.direction ??
+        "callees";
+    const depth = input.depth ?? 3;
+    const results = direction === "callers"
+        ? tracer.callers(ctx.project.id, input.symbolId, depth)
+        : tracer.callees(ctx.project.id, input.symbolId, depth);
+    return {
+        direction,
+        depth,
+        results: results.map((item) => ({
+            id: item.symbol.id,
+            name: item.symbol.name,
+            qualifiedName: item.symbol
+                .qualifiedName,
+            type: item.symbol.type,
+            filePath: item.symbol.filePath,
+            depth: item.depth,
+        })),
+    };
+}

package/dist/src/memory/activity.js

@@ -0,0 +1,5 @@
+export function getActivity(engine, projectId, limit = 20) {
+    return engine
+        .byType(projectId, "activity")
+        .slice(0, limit);
+}