toolnet-memory 0.2.0

package/dist/src/capture/activity-capture.js

@@ -0,0 +1,21 @@
+import { randomUUID, } from "node:crypto";
+import { Sanitizer } from "../security/sanitizer.js";
+export class ActivityCapture {
+    queue;
+    sanitizer = new Sanitizer();
+    constructor(queue) {
+        this.queue = queue;
+    }
+    capture(projectId, type, data = {}) {
+        const event = {
+            id: randomUUID(),
+            projectId,
+            type,
+            timestamp: new Date().toISOString(),
+            data: this.sanitizer
+                .sanitizeValue(data),
+        };
+        this.queue.push(event);
+        return event;
+    }
+}

package/dist/src/capture/command-capture.js

@@ -0,0 +1,12 @@
+export class CommandCapture {
+    capture;
+    constructor(capture) {
+        this.capture = capture;
+    }
+    record(projectId, command, exitCode) {
+        return this.capture.capture(projectId, "command", {
+            command,
+            exitCode,
+        });
+    }
+}

package/dist/src/capture/error-capture.js

@@ -0,0 +1,14 @@
+export class ErrorCapture {
+    capture;
+    constructor(capture) {
+        this.capture = capture;
+    }
+    record(projectId, error) {
+        const message = error instanceof Error
+            ? error.message
+            : String(error);
+        return this.capture.capture(projectId, "error", {
+            message,
+        });
+    }
+}

package/dist/src/capture/event-deduplicator.js

@@ -0,0 +1,28 @@
+import { createHash } from "node:crypto";
+export class EventDeduplicator {
+    seen = new Set();
+    fingerprint(event) {
+        return createHash("sha256")
+            .update(JSON.stringify({
+            projectId: event.projectId,
+            type: event.type,
+            data: event.data,
+        }))
+            .digest("hex");
+    }
+    filter(events) {
+        const result = [];
+        for (const event of events) {
+            const hash = this.fingerprint(event);
+            if (this.seen.has(hash)) {
+                continue;
+            }
+            this.seen.add(hash);
+            result.push(event);
+        }
+        return result;
+    }
+    clear() {
+        this.seen.clear();
+    }
+}

package/dist/src/capture/event-queue.js

@@ -0,0 +1,20 @@
+export class EventQueue {
+    events = [];
+    push(event) {
+        this.events.push(event);
+    }
+    drain() {
+        const items = [...this.events];
+        this.events.length = 0;
+        return items;
+    }
+    list() {
+        return [...this.events];
+    }
+    size() {
+        return this.events.length;
+    }
+    shouldFlush(maxEvents) {
+        return this.events.length >= maxEvents;
+    }
+}

package/dist/src/capture/file-capture.js

@@ -0,0 +1,23 @@
+import { isSensitiveFile, } from "../security/file-filter.js";
+export class FileCapture {
+    capture;
+    constructor(capture) {
+        this.capture = capture;
+    }
+    read(projectId, filePath) {
+        if (isSensitiveFile(filePath)) {
+            return null;
+        }
+        return this.capture.capture(projectId, "file_read", {
+            filePath,
+        });
+    }
+    write(projectId, filePath) {
+        if (isSensitiveFile(filePath)) {
+            return null;
+        }
+        return this.capture.capture(projectId, "file_write", {
+            filePath,
+        });
+    }
+}

package/dist/src/capture/index.js

@@ -0,0 +1,8 @@
+export * from "./event-queue.js";
+export * from "./event-deduplicator.js";
+export * from "./activity-capture.js";
+export * from "./session-capture.js";
+export * from "./tool-capture.js";
+export * from "./file-capture.js";
+export * from "./command-capture.js";
+export * from "./error-capture.js";

package/dist/src/capture/session-capture.js

@@ -0,0 +1,18 @@
+import { randomUUID, } from "node:crypto";
+export class SessionCapture {
+    capture;
+    sessionId = randomUUID();
+    constructor(capture) {
+        this.capture = capture;
+    }
+    start(projectId) {
+        return this.capture.capture(projectId, "session_start", {
+            sessionId: this.sessionId,
+        });
+    }
+    end(projectId) {
+        return this.capture.capture(projectId, "session_end", {
+            sessionId: this.sessionId,
+        });
+    }
+}

package/dist/src/capture/tool-capture.js

@@ -0,0 +1,13 @@
+export class ToolCapture {
+    capture;
+    constructor(capture) {
+        this.capture = capture;
+    }
+    record(projectId, tool, input, output) {
+        return this.capture.capture(projectId, "tool_call", {
+            tool,
+            input,
+            output,
+        });
+    }
+}

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

@@ -0,0 +1,26 @@
+import { DeadCodeAnalyzer, } from "./dead-code-analyzer.js";
+import { DependencyAnalyzer, } from "./dependency-analyzer.js";
+export class CodeAnalysisEngine {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    analyze(projectId) {
+        const deadCode = new DeadCodeAnalyzer(this.graph).analyze(projectId);
+        const dependencies = new DependencyAnalyzer(this.graph).analyze(projectId);
+        return {
+            version: 1,
+            projectId,
+            updatedAt: new Date()
+                .toISOString(),
+            summary: {
+                deadCodeCandidates: deadCode.length,
+                highConfidenceDeadCode: deadCode.filter((item) => item.confidence ===
+                    "high").length,
+                files: dependencies.length,
+            },
+            deadCode,
+            dependencies,
+        };
+    }
+}

package/dist/src/code-intelligence/analysis/dead-code-analyzer.js

@@ -0,0 +1,127 @@
+import { EntryPointDetector, } from "../architecture/entry-points.js";
+const USAGE_EDGES = new Set([
+    "CALLS",
+    "CALL_REFERENCE",
+    "IMPORTS",
+    "USES_TYPE",
+    "WRITES",
+    "INHERITS",
+    "IMPLEMENTS",
+    "ROUTE",
+    "TESTS",
+]);
+function normalize(value) {
+    return value
+        .replaceAll("\\", "/")
+        .toLowerCase();
+}
+function isTestFile(filePath) {
+    const path = normalize(filePath);
+    return (path.startsWith("tests/") ||
+        path.includes("/tests/") ||
+        path.includes("__tests__") ||
+        /\.(test|spec)\.[^.]+$/
+            .test(path));
+}
+function looksPublicApi(symbol) {
+    const path = normalize(symbol.filePath);
+    return (path.startsWith("bin/") ||
+        /(^|\/)index\.[^.]+$/
+            .test(path) ||
+        /(^|\/)(main|server|cli)\.[^.]+$/
+            .test(path));
+}
+export class DeadCodeAnalyzer {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    analyze(projectId) {
+        const symbols = this.graph.allSymbols(projectId);
+        const edges = this.graph.allEdges(projectId);
+        const entrySymbols = new Set(new EntryPointDetector(this.graph)
+            .detect(projectId)
+            .map((entry) => entry.symbolId));
+        const candidates = [];
+        for (const symbol of symbols) {
+            if (![
+                "function",
+                "method",
+                "class",
+                "interface",
+                "property",
+            ].includes(symbol.type)) {
+                continue;
+            }
+            if (isTestFile(symbol.filePath) ||
+                entrySymbols.has(symbol.id) ||
+                looksPublicApi(symbol)) {
+                continue;
+            }
+            const incoming = edges.filter((edge) => edge.to ===
+                symbol.id &&
+                USAGE_EDGES.has(edge.type));
+            if (incoming.length >
+                0) {
+                continue;
+            }
+            const outgoing = edges.filter((edge) => edge.from ===
+                symbol.id &&
+                USAGE_EDGES.has(edge.type));
+            const reasons = [
+                "no incoming usage edge",
+            ];
+            let score = 50;
+            if (symbol.type ===
+                "function" ||
+                symbol.type ===
+                    "method") {
+                score +=
+                    20;
+                reasons.push("callable symbol");
+            }
+            if (symbol.type ===
+                "property") {
+                score -=
+                    15;
+            }
+            if (outgoing.length ===
+                0) {
+                score +=
+                    10;
+                reasons.push("no outgoing dependency");
+            }
+            const path = normalize(symbol.filePath);
+            if (path.includes("/internal/")) {
+                score +=
+                    10;
+                reasons.push("internal implementation");
+            }
+            if (symbol.name
+                .startsWith("_")) {
+                score +=
+                    5;
+            }
+            const confidence = score >= 75
+                ? "high"
+                : score >= 55
+                    ? "medium"
+                    : "low";
+            candidates.push({
+                symbolId: symbol.id,
+                name: symbol.name,
+                qualifiedName: symbol.qualifiedName,
+                type: symbol.type,
+                filePath: symbol.filePath,
+                startLine: symbol.startLine,
+                confidence,
+                score,
+                reasons,
+            });
+        }
+        return candidates.sort((a, b) => b.score -
+            a.score ||
+            a.filePath.localeCompare(b.filePath) ||
+            a.name.localeCompare(b.name));
+    }
+}

package/dist/src/code-intelligence/analysis/dependency-analyzer.js

@@ -0,0 +1,66 @@
+const EDGE_TYPES = new Set([
+    "CALLS",
+    "CALL_REFERENCE",
+    "IMPORTS",
+    "USES_TYPE",
+    "WRITES",
+    "INHERITS",
+    "IMPLEMENTS",
+    "ROUTE",
+]);
+export class DependencyAnalyzer {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    analyze(projectId) {
+        const symbols = this.graph.allSymbols(projectId);
+        const edges = this.graph
+            .allEdges(projectId)
+            .filter((edge) => EDGE_TYPES.has(edge.type));
+        const symbolById = new Map(symbols.map((symbol) => [
+            symbol.id,
+            symbol,
+        ]));
+        const files = [
+            ...new Set(symbols.map((symbol) => symbol.filePath)),
+        ].sort();
+        return files.map((filePath) => {
+            const dependencies = new Set();
+            const dependents = new Set();
+            let outgoingEdges = 0;
+            let incomingEdges = 0;
+            for (const edge of edges) {
+                const from = symbolById.get(edge.from);
+                const to = symbolById.get(edge.to);
+                if (!from ||
+                    !to ||
+                    from.filePath ===
+                        to.filePath) {
+                    continue;
+                }
+                if (from.filePath ===
+                    filePath) {
+                    dependencies.add(to.filePath);
+                    outgoingEdges++;
+                }
+                if (to.filePath ===
+                    filePath) {
+                    dependents.add(from.filePath);
+                    incomingEdges++;
+                }
+            }
+            return {
+                filePath,
+                dependencies: [
+                    ...dependencies,
+                ].sort(),
+                dependents: [
+                    ...dependents,
+                ].sort(),
+                outgoingEdges,
+                incomingEdges,
+            };
+        });
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./dead-code-analyzer.js";
+export * from "./dependency-analyzer.js";
+export * from "./analysis-engine.js";

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

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

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

@@ -0,0 +1,48 @@
+import { ClusterDetector, } from "./clusters.js";
+import { EntryPointDetector, } from "./entry-points.js";
+import { HotspotAnalyzer, } from "./hotspots.js";
+import { LayerDetector, } from "./layers.js";
+export class ArchitectureEngine {
+    graph;
+    entryPoints;
+    hotspots;
+    layers;
+    clusters;
+    constructor(graph) {
+        this.graph = graph;
+        this.entryPoints =
+            new EntryPointDetector(graph);
+        this.hotspots =
+            new HotspotAnalyzer(graph);
+        this.layers =
+            new LayerDetector(graph);
+        this.clusters =
+            new ClusterDetector(graph);
+    }
+    analyze(projectId) {
+        const entryPoints = this.entryPoints.detect(projectId);
+        const hotspots = this.hotspots.analyze(projectId);
+        const layers = this.layers.detect(projectId);
+        const clusters = this.clusters.detect(projectId);
+        const files = new Set(this.graph
+            .allSymbols(projectId)
+            .map((symbol) => symbol.filePath));
+        return {
+            version: 1,
+            projectId,
+            updatedAt: new Date()
+                .toISOString(),
+            summary: {
+                files: files.size,
+                entryPoints: entryPoints.length,
+                hotspots: hotspots.length,
+                layers: layers.length,
+                clusters: clusters.length,
+            },
+            entryPoints,
+            hotspots,
+            layers,
+            clusters,
+        };
+    }
+}