toolnet-memory 0.2.0

package/dist/src/code-intelligence/symbols/reference-resolver.js

@@ -0,0 +1,21 @@
+export class ReferenceResolver {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    findSymbol(projectId, name) {
+        return this.graph.findByName(projectId, name);
+    }
+    findCallers(projectId, symbolId) {
+        const callerIds = this.graph
+            .allEdges(projectId)
+            .filter((edge) => edge.type ===
+            "CALLS" &&
+            edge.to ===
+                symbolId)
+            .map((edge) => edge.from);
+        return callerIds
+            .map((id) => this.graph.getSymbol(id))
+            .filter((symbol) => Boolean(symbol));
+    }
+}

package/dist/src/code-intelligence/symbols/symbol-extractor.js

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

package/dist/src/code-intelligence/test-analysis.js

@@ -0,0 +1,72 @@
+import "dotenv/config";
+import { loadConfig, ProjectManager, } from "../core/index.js";
+import { createStorageProvider, withStorageRetry, ProjectScopedStorageProvider, PersistentCodeAnalysisStore, PersistentCodeGraphStore, } from "../storage/index.js";
+import { CodeAnalysisEngine, CodeGraphStore, GraphQueryEngine, } from "./index.js";
+async function main() {
+    const config = loadConfig();
+    const project = new ProjectManager()
+        .detect();
+    const rawStorage = withStorageRetry(createStorageProvider({
+        provider: config.storage.provider,
+        huggingface: config.storage.huggingface,
+        localRoot: config.storage.localRoot,
+    }), {
+        attempts: 3,
+    });
+    const storage = new ProjectScopedStorageProvider(rawStorage, project.id, project.name, project.remote ?? project.name);
+    const graphSnapshot = await new PersistentCodeGraphStore(storage).load(project.id);
+    if (!graphSnapshot) {
+        throw new Error("Code graph missing");
+    }
+    const graph = new CodeGraphStore();
+    graph.import(graphSnapshot.symbols, graphSnapshot.edges);
+    const analysis = new CodeAnalysisEngine(graph).analyze(project.id);
+    await new PersistentCodeAnalysisStore(storage).save(analysis);
+    const query = new GraphQueryEngine(graph);
+    const memoryStore = query.findSymbols(project.id, "MemoryStore")[0];
+    console.log({
+        ok: true,
+        project: project.name,
+        summary: analysis.summary,
+        highConfidenceDeadCode: analysis.deadCode
+            .filter((item) => item.confidence ===
+            "high")
+            .slice(0, 20)
+            .map((item) => ({
+            symbol: item.qualifiedName ??
+                item.name,
+            type: item.type,
+            file: item.filePath,
+            line: item.startLine,
+            score: item.score,
+        })),
+        topDependencyHubs: analysis.dependencies
+            .slice()
+            .sort((a, b) => (b.incomingEdges +
+            b.outgoingEdges) -
+            (a.incomingEdges +
+                a.outgoingEdges))
+            .slice(0, 15)
+            .map((item) => ({
+            file: item.filePath,
+            dependencies: item.dependencies.length,
+            dependents: item.dependents.length,
+            incoming: item.incomingEdges,
+            outgoing: item.outgoingEdges,
+        })),
+        memoryStore: memoryStore
+            ? {
+                symbol: memoryStore
+                    .qualifiedName ??
+                    memoryStore.name,
+                callers: query.callers(project.id, memoryStore.id).length,
+                dependents: query.dependents(project.id, memoryStore.id).length,
+                dependencies: query.dependencies(project.id, memoryStore.id).length,
+            }
+            : null,
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/code-intelligence/test-architecture.js

@@ -0,0 +1,67 @@
+import "dotenv/config";
+import { loadConfig, ProjectManager, } from "../core/index.js";
+import { createStorageProvider, withStorageRetry, ProjectScopedStorageProvider, PersistentArchitectureStore, PersistentCodeGraphStore, } from "../storage/index.js";
+import { ArchitectureEngine, CodeGraphStore, } from "./index.js";
+async function main() {
+    const config = loadConfig();
+    const project = new ProjectManager()
+        .detect();
+    const rawStorage = withStorageRetry(createStorageProvider({
+        provider: config.storage.provider,
+        huggingface: config.storage.huggingface,
+        localRoot: config.storage.localRoot,
+    }), {
+        attempts: 3,
+    });
+    const storage = new ProjectScopedStorageProvider(rawStorage, project.id, project.name, project.remote ?? project.name);
+    const graphSnapshot = await new PersistentCodeGraphStore(storage).load(project.id);
+    if (!graphSnapshot) {
+        throw new Error("Code graph missing");
+    }
+    const graph = new CodeGraphStore();
+    graph.import(graphSnapshot.symbols, graphSnapshot.edges);
+    const architecture = new ArchitectureEngine(graph).analyze(project.id);
+    await new PersistentArchitectureStore(storage).save(architecture);
+    const layerCounts = architecture.layers
+        .reduce((result, item) => {
+        result[item.layer] =
+            (result[item.layer] ?? 0) + 1;
+        return result;
+    }, {});
+    console.log({
+        ok: true,
+        project: project.name,
+        summary: architecture.summary,
+        layers: layerCounts,
+        topEntryPoints: architecture.entryPoints
+            .slice(0, 10)
+            .map((item) => ({
+            kind: item.kind,
+            file: item.filePath,
+            name: item.name,
+            score: item.score,
+        })),
+        topHotspots: architecture.hotspots
+            .slice(0, 10)
+            .map((item) => ({
+            file: item.filePath,
+            score: item.score,
+            incoming: item.incoming,
+            outgoing: item.outgoing,
+        })),
+        largestClusters: architecture.clusters
+            .slice(0, 10)
+            .map((item) => ({
+            id: item.id,
+            label: item.label,
+            subsystem: item.subsystem,
+            size: item.size,
+            cohesion: item.cohesion,
+            sample: item.files.slice(0, 5),
+        })),
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/code-intelligence/test-impact.js

@@ -0,0 +1,47 @@
+import "dotenv/config";
+import { loadConfig, ProjectManager, } from "../core/index.js";
+import { createStorageProvider, withStorageRetry, ProjectScopedStorageProvider, PersistentCodeGraphStore, } from "../storage/index.js";
+import { CodeGraphStore, ImpactGuard, } from "./index.js";
+async function main() {
+    const config = loadConfig();
+    const project = new ProjectManager()
+        .detect();
+    const raw = withStorageRetry(createStorageProvider({
+        provider: config.storage.provider,
+        huggingface: config.storage.huggingface,
+        localRoot: config.storage.localRoot,
+    }), {
+        attempts: 3,
+    });
+    const storage = new ProjectScopedStorageProvider(raw, project.id, project.name, project.remote ?? project.name);
+    const snapshot = await new PersistentCodeGraphStore(storage).load(project.id);
+    if (!snapshot) {
+        throw new Error("Code graph missing");
+    }
+    const graph = new CodeGraphStore();
+    graph.import(snapshot.symbols, snapshot.edges);
+    const guard = new ImpactGuard(graph);
+    const filePath = process.argv[2];
+    const result = filePath
+        ? guard.analyzeFile(project.id, filePath)
+        : await guard.analyzeGitDiff(project.id, project.rootPath);
+    console.log({
+        risk: result.risk,
+        riskScore: result.riskScore,
+        changedSymbols: result.changedSymbols.map((item) => ({
+            symbol: item.symbol
+                .qualifiedName,
+            file: item.symbol
+                .filePath,
+            type: item.symbol
+                .type,
+        })),
+        impactedFiles: result.impactedFiles,
+        suggestedTests: result.suggestedTests,
+        impactedCount: result.impacted.length,
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/code-intelligence/test-incremental.js

@@ -0,0 +1,24 @@
+import "dotenv/config";
+import { loadConfig, ProjectManager, } from "../core/index.js";
+import { createStorageProvider, ProjectScopedStorageProvider, } from "../storage/index.js";
+import { IncrementalRepositoryIndexer, } from "./incremental/incremental-indexer.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 storage = new ProjectScopedStorageProvider(rawStorage, project.id, project.name, project.remote ?? project.name);
+    const result = await new IncrementalRepositoryIndexer(storage).index(project.id, project.rootPath);
+    console.log({
+        ok: true,
+        storage: storage.name,
+        ...result,
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/code-intelligence/test-index.js

@@ -0,0 +1,39 @@
+import "dotenv/config";
+import { loadConfig, ProjectManager, } from "../core/index.js";
+import { RepositoryIndexer, getArchitecture, } from "./index.js";
+import { createStorageProvider, PersistentCodeGraphStore, ProjectScopedStorageProvider, } from "../storage/index.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 storage = new ProjectScopedStorageProvider(rawStorage, project.id, project.name, project.remote ?? project.name);
+    const result = await new RepositoryIndexer()
+        .index(project.id, project.rootPath);
+    const architecture = getArchitecture(result.graph, project.id);
+    const persistent = new PersistentCodeGraphStore(storage);
+    await persistent.save({
+        version: 1,
+        projectId: project.id,
+        updatedAt: new Date()
+            .toISOString(),
+        files: result.files,
+        symbols: result.graph
+            .allSymbols(project.id),
+        edges: result.graph
+            .allEdges(project.id),
+    });
+    console.log({
+        ok: true,
+        storage: storage.name,
+        ...architecture,
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/code-intelligence/test-resolution.js

@@ -0,0 +1,54 @@
+import "dotenv/config";
+import { loadConfig, ProjectManager, } from "../core/index.js";
+import { createStorageProvider, withStorageRetry, ProjectScopedStorageProvider, PersistentCodeGraphStore, PersistentTypeResolutionStore, } from "../storage/index.js";
+import { CodeGraphStore, TypeScriptTypeResolver, } from "./index.js";
+async function main() {
+    const config = loadConfig();
+    const project = new ProjectManager()
+        .detect();
+    const rawStorage = withStorageRetry(createStorageProvider({
+        provider: config.storage.provider,
+        huggingface: config.storage.huggingface,
+        localRoot: config.storage.localRoot,
+    }), {
+        attempts: 3,
+    });
+    const storage = new ProjectScopedStorageProvider(rawStorage, project.id, project.name, project.remote ?? project.name);
+    const graphSnapshot = await new PersistentCodeGraphStore(storage).load(project.id);
+    if (!graphSnapshot) {
+        throw new Error("Code graph missing. Run code:index:test first.");
+    }
+    const graph = new CodeGraphStore();
+    graph.import(graphSnapshot.symbols, graphSnapshot.edges);
+    const resolver = new TypeScriptTypeResolver(graph);
+    const resolution = await resolver.resolveProject(project.id, project.rootPath);
+    await new PersistentTypeResolutionStore(storage).save(resolution);
+    console.log({
+        ok: true,
+        project: project.name,
+        total: resolution.total,
+        exact: resolution.exact,
+        high: resolution.high,
+        fallback: resolution.fallback,
+        exactRate: resolution.total
+            ? Number(((resolution.exact /
+                resolution.total) *
+                100).toFixed(2))
+            : 0,
+        samples: resolution.resolutions
+            .filter((item) => item.targetFile)
+            .slice(0, 10)
+            .map((item) => ({
+            expression: item.expression,
+            from: `${item.sourceFile}:${item.sourceLine}`,
+            to: `${item.targetFile}:${item.targetLine ?? "?"}`,
+            target: item.targetQualifiedName ??
+                item.targetName,
+            confidence: item.confidence,
+        })),
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/code-intelligence/test-rich-graph.js

@@ -0,0 +1,48 @@
+import "dotenv/config";
+import { loadConfig, ProjectManager, } from "../core/index.js";
+import { createStorageProvider, withStorageRetry, ProjectScopedStorageProvider, PersistentCodeGraphStore, PersistentTypeResolutionStore, } from "../storage/index.js";
+import { CodeGraphStore, RichGraphEnricher, getArchitecture, } from "./index.js";
+async function main() {
+    const config = loadConfig();
+    const project = new ProjectManager()
+        .detect();
+    const raw = withStorageRetry(createStorageProvider({
+        provider: config.storage.provider,
+        huggingface: config.storage.huggingface,
+        localRoot: config.storage.localRoot,
+    }), {
+        attempts: 3,
+    });
+    const storage = new ProjectScopedStorageProvider(raw, project.id, project.name, project.remote ?? project.name);
+    const store = new PersistentCodeGraphStore(storage);
+    const snapshot = await store.load(project.id);
+    if (!snapshot) {
+        throw new Error("Code graph missing");
+    }
+    const graph = new CodeGraphStore();
+    graph.import(snapshot.symbols, snapshot.edges);
+    const resolution = await new PersistentTypeResolutionStore(storage).load(project.id);
+    const stats = new RichGraphEnricher(graph).enrich(project.id, project.rootPath, resolution);
+    const symbols = graph.allSymbols(project.id);
+    const edges = graph.allEdges(project.id);
+    await store.save({
+        version: 1,
+        projectId: project.id,
+        updatedAt: new Date()
+            .toISOString(),
+        files: symbols.filter((item) => item.type ===
+            "file").length,
+        symbols,
+        edges,
+    });
+    console.log({
+        ok: true,
+        project: project.name,
+        added: stats,
+        architecture: getArchitecture(graph, project.id),
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/code-intelligence/test-semantic.js

@@ -0,0 +1,57 @@
+import "dotenv/config";
+import { loadConfig, ProjectManager, } from "../core/index.js";
+import { createStorageProvider, PersistentCodeGraphStore, ProjectScopedStorageProvider, } from "../storage/index.js";
+import { CodeGraphStore, SemanticCodeEngine, } from "./index.js";
+import { createEmbeddingProvider, } from "../embeddings/index.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 storage = new ProjectScopedStorageProvider(rawStorage, project.id, project.name, project.remote ?? project.name);
+    const graph = new CodeGraphStore();
+    const snapshot = await new PersistentCodeGraphStore(storage).load(project.id);
+    if (!snapshot) {
+        throw new Error("Code graph missing. Run npm run code:index:test first.");
+    }
+    graph.import(snapshot.symbols, snapshot.edges);
+    const engine = new SemanticCodeEngine({
+        projectId: project.id,
+        rootPath: project.rootPath,
+        model: process.env
+            .HF_EMBEDDING_MODEL ??
+            "sentence-transformers/all-MiniLM-L6-v2",
+        storage,
+        embeddings: createEmbeddingProvider(),
+        graph,
+    });
+    const stats = await engine.initialize();
+    const query = process.argv
+        .slice(2)
+        .join(" ") ||
+        "memory storage hugging face";
+    const results = await engine.search(query, 5);
+    console.log({
+        ok: true,
+        query,
+        ...stats,
+        results: results.map((item) => ({
+            score: Number(item.score
+                .toFixed(4)),
+            file: item.chunk.filePath,
+            symbol: item.chunk.symbolName,
+            lines: `${item.chunk.startLine}-${item.chunk.endLine}`,
+            preview: item.chunk.content
+                .replace(/\s+/g, " ")
+                .slice(0, 140),
+        })),
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/code-intelligence/test-visualization.js

@@ -0,0 +1,36 @@
+import "dotenv/config";
+import { loadConfig, ProjectManager, } from "../core/index.js";
+import { createStorageProvider, withStorageRetry, ProjectScopedStorageProvider, PersistentArchitectureStore, PersistentCodeAnalysisStore, PersistentCodeGraphStore, PersistentVisualizationStore, } from "../storage/index.js";
+import { CodeGraphStore, VisualizationBuilder, } from "./index.js";
+async function main() {
+    const config = loadConfig();
+    const project = new ProjectManager()
+        .detect();
+    const rawStorage = withStorageRetry(createStorageProvider({
+        provider: config.storage.provider,
+        huggingface: config.storage.huggingface,
+        localRoot: config.storage.localRoot,
+    }), {
+        attempts: 3,
+    });
+    const storage = new ProjectScopedStorageProvider(rawStorage, project.id, project.name, project.remote ?? project.name);
+    const graphSnapshot = await new PersistentCodeGraphStore(storage).load(project.id);
+    if (!graphSnapshot) {
+        throw new Error("Code graph missing");
+    }
+    const architecture = await new PersistentArchitectureStore(storage).load(project.id);
+    const analysis = await new PersistentCodeAnalysisStore(storage).load(project.id);
+    const graph = new CodeGraphStore();
+    graph.import(graphSnapshot.symbols, graphSnapshot.edges);
+    const visualization = new VisualizationBuilder(graph).build(project.id, architecture, analysis);
+    await new PersistentVisualizationStore(storage).save(visualization);
+    console.log({
+        ok: true,
+        project: project.name,
+        ...visualization.summary,
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/code-intelligence/types.js

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

package/dist/src/code-intelligence/visualization/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./visualization-builder.js";

package/dist/src/code-intelligence/visualization/types.js

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

package/dist/src/code-intelligence/visualization/visualization-builder.js

@@ -0,0 +1,104 @@
+export class VisualizationBuilder {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    build(projectId, architecture, analysis) {
+        const symbols = this.graph.allSymbols(projectId);
+        const edges = this.graph.allEdges(projectId);
+        const layers = new Map(architecture
+            ?.layers
+            .map((item) => [
+            item.filePath,
+            item.layer,
+        ]) ??
+            []);
+        const clusterByFile = new Map();
+        for (const cluster of architecture?.clusters ??
+            []) {
+            for (const file of cluster.files) {
+                clusterByFile.set(file, {
+                    id: cluster.id,
+                    label: cluster.label,
+                });
+            }
+        }
+        const hotspotByFile = new Map(architecture
+            ?.hotspots
+            .map((item) => [
+            item.filePath,
+            item.score,
+        ]) ??
+            []);
+        const deadCodeBySymbol = new Map(analysis
+            ?.deadCode
+            .map((item) => [
+            item.symbolId,
+            {
+                confidence: item.confidence,
+                score: item.score,
+            },
+        ]) ??
+            []);
+        const incoming = new Map();
+        const outgoing = new Map();
+        for (const edge of edges) {
+            outgoing.set(edge.from, (outgoing.get(edge.from) ?? 0) + 1);
+            incoming.set(edge.to, (incoming.get(edge.to) ?? 0) + 1);
+        }
+        const nodes = symbols.map((symbol) => {
+            const cluster = clusterByFile.get(symbol.filePath);
+            return {
+                id: symbol.id,
+                name: symbol.name,
+                qualifiedName: symbol.qualifiedName,
+                type: symbol.type,
+                filePath: symbol.filePath,
+                layer: layers.get(symbol.filePath),
+                cluster: cluster?.id,
+                clusterLabel: cluster?.label,
+                hotspotScore: hotspotByFile.get(symbol.filePath),
+                deadCode: deadCodeBySymbol.get(symbol.id),
+                incoming: incoming.get(symbol.id) ?? 0,
+                outgoing: outgoing.get(symbol.id) ?? 0,
+            };
+        });
+        const symbolIds = new Set(nodes.map((node) => node.id));
+        const links = edges
+            .filter((edge) => symbolIds.has(edge.from) &&
+            symbolIds.has(edge.to))
+            .map((edge) => ({
+            source: edge.from,
+            target: edge.to,
+            type: edge.type,
+            confidence: typeof edge.metadata
+                ?.confidence ===
+                "string"
+                ? edge.metadata
+                    .confidence
+                : undefined,
+            resolver: typeof edge.metadata
+                ?.resolver ===
+                "string"
+                ? edge.metadata
+                    .resolver
+                : undefined,
+        }));
+        return {
+            version: 1,
+            projectId,
+            generatedAt: new Date()
+                .toISOString(),
+            summary: {
+                nodes: nodes.length,
+                links: links.length,
+                files: new Set(nodes.map((node) => node.filePath)).size,
+                clusters: new Set(nodes
+                    .map((node) => node.cluster)
+                    .filter(Boolean)).size,
+            },
+            nodes,
+            links,
+        };
+    }
+}

package/dist/src/core/config.js

@@ -0,0 +1,66 @@
+import "./global-env.js";
+function envBool(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    return [
+        "1",
+        "true",
+        "yes",
+        "on",
+    ].includes(value.toLowerCase());
+}
+function envNumber(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed)
+        ? parsed
+        : fallback;
+}
+export function loadConfig() {
+    return {
+        memory: {
+            autoCapture: envBool(process.env
+                .MEMORY_AUTO_CAPTURE, true),
+            autoRetrieve: envBool(process.env
+                .MEMORY_AUTO_RETRIEVE, true),
+            autoSummarize: envBool(process.env
+                .MEMORY_AUTO_SUMMARIZE, true),
+            autoSync: envBool(process.env
+                .MEMORY_AUTO_SYNC, true),
+        },
+        retrieval: {
+            maxCandidates: envNumber(process.env
+                .MEMORY_MAX_CANDIDATES, 50),
+            rerankTop: envNumber(process.env
+                .MEMORY_RERANK_TOP, 10),
+            finalContext: envNumber(process.env
+                .MEMORY_FINAL_CONTEXT, 5),
+            tokenBudget: envNumber(process.env
+                .MEMORY_TOKEN_BUDGET, 2000),
+        },
+        storage: {
+            provider: process.env
+                .MEMORY_STORAGE_PROVIDER ??
+                "huggingface",
+            huggingface: {
+                namespace: process.env
+                    .HF_NAMESPACE,
+                bucket: process.env
+                    .HF_BUCKET,
+                accessKeyId: process.env
+                    .HF_S3_ACCESS_KEY_ID,
+                secretAccessKey: process.env
+                    .HF_S3_SECRET_ACCESS_KEY,
+            },
+            localRoot: process.env
+                .MEMORY_LOCAL_STORAGE_PATH,
+        },
+        cache: {
+            maxMb: envNumber(process.env
+                .MEMORY_LOCAL_CACHE_MB, 200),
+        },
+    };
+}