gnosys 4.0.0

package/dist/lib/tags.js

@@ -0,0 +1,109 @@
+/**
+ * Gnosys Tag Registry — Categorized controlled vocabulary for tags.
+ * Stored in .config/tags.json. The ingestion LLM must use existing tags
+ * but can propose new ones for approval.
+ */
+import fs from "fs/promises";
+import path from "path";
+const DEFAULT_REGISTRY = {
+    domain: [
+        "auth",
+        "database",
+        "frontend",
+        "backend",
+        "deployment",
+        "api",
+        "cli",
+        "mcp",
+        "wiki",
+        "obsidian",
+        "architecture",
+        "retrieval",
+        "search",
+        "ingestion",
+        "memory",
+        "lensing",
+        "decay",
+        "reinforcement",
+        "contradiction",
+        "tags",
+        "git",
+        "typescript",
+        "tooling",
+        "roadmap",
+        "scope",
+    ],
+    type: [
+        "decision",
+        "convention",
+        "architecture",
+        "concept",
+        "requirement",
+        "landscape",
+        "open-question",
+    ],
+    concern: [
+        "security",
+        "performance",
+        "scalability",
+        "dx",
+        "adoption",
+        "community",
+        "portability",
+    ],
+    status_tag: ["core", "experimental", "deprecated", "phased"],
+};
+export class GnosysTagRegistry {
+    registryPath;
+    registry;
+    constructor(storePath) {
+        this.registryPath = path.join(storePath, ".config", "tags.json");
+        this.registry = { ...DEFAULT_REGISTRY };
+    }
+    async load() {
+        try {
+            const raw = await fs.readFile(this.registryPath, "utf-8");
+            this.registry = JSON.parse(raw);
+        }
+        catch {
+            // File doesn't exist yet — use defaults and create it
+            await this.save();
+        }
+        return this.registry;
+    }
+    async save() {
+        const dir = path.dirname(this.registryPath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(this.registryPath, JSON.stringify(this.registry, null, 2), "utf-8");
+    }
+    getRegistry() {
+        return this.registry;
+    }
+    getAllTags() {
+        return [...new Set(Object.values(this.registry).flat())].sort();
+    }
+    getTagsByCategory(category) {
+        return this.registry[category] || [];
+    }
+    hasTag(tag) {
+        return Object.values(this.registry).some((tags) => tags.includes(tag));
+    }
+    findTagCategory(tag) {
+        for (const [category, tags] of Object.entries(this.registry)) {
+            if (tags.includes(tag))
+                return category;
+        }
+        return null;
+    }
+    async addTag(category, tag) {
+        if (!this.registry[category]) {
+            this.registry[category] = [];
+        }
+        if (this.registry[category].includes(tag))
+            return false;
+        this.registry[category].push(tag);
+        await this.save();
+        return true;
+    }
+}
+//# sourceMappingURL=tags.js.map

package/dist/lib/tags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.js","sourceRoot":"","sources":["../../src/lib/tags.ts"],"names":[],"mappings":"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"}

package/dist/lib/timeline.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Gnosys Timeline — Temporal views and statistics for memory stores.
+ *
+ * Group memories by time period to see knowledge evolution.
+ * Compute summary statistics across the store.
+ */
+import { Memory } from "./store.js";
+export type TimePeriod = "day" | "week" | "month" | "year";
+export interface TimelineEntry {
+    period: string;
+    created: number;
+    modified: number;
+    titles: string[];
+}
+export interface MemoryStats {
+    totalCount: number;
+    byCategory: Record<string, number>;
+    byStatus: Record<string, number>;
+    byAuthor: Record<string, number>;
+    byAuthority: Record<string, number>;
+    averageConfidence: number;
+    oldestCreated: string | null;
+    newestCreated: string | null;
+    lastModified: string | null;
+}
+/**
+ * Group memories by time period based on their created/modified dates.
+ */
+export declare function groupByPeriod(memories: Memory[], period: TimePeriod): TimelineEntry[];
+/**
+ * Compute summary statistics across all memories.
+ */
+export declare function computeStats(memories: Memory[]): MemoryStats;
+//# sourceMappingURL=timeline.d.ts.map

package/dist/lib/timeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline.d.ts","sourceRoot":"","sources":["../../src/lib/timeline.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEpC,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAE3D,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,UAAU,GAAG,aAAa,EAAE,CAkCrF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,WAAW,CAmC5D"}

package/dist/lib/timeline.js

@@ -0,0 +1,116 @@
+/**
+ * Gnosys Timeline — Temporal views and statistics for memory stores.
+ *
+ * Group memories by time period to see knowledge evolution.
+ * Compute summary statistics across the store.
+ */
+/**
+ * Group memories by time period based on their created/modified dates.
+ */
+export function groupByPeriod(memories, period) {
+    const createdMap = new Map();
+    const modifiedMap = new Map();
+    for (const m of memories) {
+        const createdKey = toPeriodKey(m.frontmatter.created, period);
+        if (createdKey) {
+            const entry = createdMap.get(createdKey) || { count: 0, titles: [] };
+            entry.count++;
+            entry.titles.push(m.frontmatter.title);
+            createdMap.set(createdKey, entry);
+        }
+        const modifiedKey = toPeriodKey(m.frontmatter.modified, period);
+        if (modifiedKey && modifiedKey !== createdKey) {
+            modifiedMap.set(modifiedKey, (modifiedMap.get(modifiedKey) || 0) + 1);
+        }
+    }
+    // Merge all period keys
+    const allKeys = new Set([...createdMap.keys(), ...modifiedMap.keys()]);
+    const entries = [];
+    for (const key of allKeys) {
+        const created = createdMap.get(key);
+        entries.push({
+            period: key,
+            created: created?.count || 0,
+            modified: modifiedMap.get(key) || 0,
+            titles: created?.titles || [],
+        });
+    }
+    return entries.sort((a, b) => a.period.localeCompare(b.period));
+}
+/**
+ * Compute summary statistics across all memories.
+ */
+export function computeStats(memories) {
+    const byCategory = {};
+    const byStatus = {};
+    const byAuthor = {};
+    const byAuthority = {};
+    let totalConfidence = 0;
+    let oldest = null;
+    let newest = null;
+    let lastMod = null;
+    for (const m of memories) {
+        const fm = m.frontmatter;
+        byCategory[fm.category] = (byCategory[fm.category] || 0) + 1;
+        byStatus[fm.status] = (byStatus[fm.status] || 0) + 1;
+        byAuthor[fm.author] = (byAuthor[fm.author] || 0) + 1;
+        byAuthority[fm.authority] = (byAuthority[fm.authority] || 0) + 1;
+        totalConfidence += fm.confidence;
+        if (!oldest || fm.created < oldest)
+            oldest = fm.created;
+        if (!newest || fm.created > newest)
+            newest = fm.created;
+        if (!lastMod || fm.modified > lastMod)
+            lastMod = fm.modified;
+    }
+    return {
+        totalCount: memories.length,
+        byCategory,
+        byStatus,
+        byAuthor,
+        byAuthority,
+        averageConfidence: memories.length > 0 ? Math.round((totalConfidence / memories.length) * 100) / 100 : 0,
+        oldestCreated: oldest,
+        newestCreated: newest,
+        lastModified: lastMod,
+    };
+}
+/**
+ * Convert an ISO date string to a period key.
+ */
+function toPeriodKey(dateStr, period) {
+    if (!dateStr)
+        return null;
+    // Parse the date string (YYYY-MM-DD format)
+    const parts = dateStr.split("-");
+    if (parts.length < 3)
+        return null;
+    const year = parseInt(parts[0]);
+    const month = parseInt(parts[1]);
+    const day = parseInt(parts[2]);
+    switch (period) {
+        case "day":
+            return dateStr; // Already YYYY-MM-DD
+        case "week": {
+            const d = new Date(year, month - 1, day);
+            const weekNum = getISOWeek(d);
+            return `${year}-W${String(weekNum).padStart(2, "0")}`;
+        }
+        case "month":
+            return `${year}-${String(month).padStart(2, "0")}`;
+        case "year":
+            return `${year}`;
+    }
+}
+/**
+ * Get ISO week number for a date.
+ */
+function getISOWeek(d) {
+    const date = new Date(d.getTime());
+    date.setHours(0, 0, 0, 0);
+    date.setDate(date.getDate() + 3 - ((date.getDay() + 6) % 7));
+    const week1 = new Date(date.getFullYear(), 0, 4);
+    return (1 +
+        Math.round(((date.getTime() - week1.getTime()) / 86400000 - 3 + ((week1.getDay() + 6) % 7)) / 7));
+}
+//# sourceMappingURL=timeline.js.map

package/dist/lib/timeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline.js","sourceRoot":"","sources":["../../src/lib/timeline.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAyBH;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,QAAkB,EAAE,MAAkB;IAClE,MAAM,UAAU,GAAG,IAAI,GAAG,EAA+C,CAAC;IAC1E,MAAM,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE9C,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,MAAM,UAAU,GAAG,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAC9D,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;YACrE,KAAK,CAAC,KAAK,EAAE,CAAC;YACd,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YACvC,UAAU,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QACpC,CAAC;QAED,MAAM,WAAW,GAAG,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAChE,IAAI,WAAW,IAAI,WAAW,KAAK,UAAU,EAAE,CAAC;YAC9C,WAAW,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACxE,CAAC;IACH,CAAC;IAED,wBAAwB;IACxB,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,IAAI,EAAE,EAAE,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACvE,MAAM,OAAO,GAAoB,EAAE,CAAC;IAEpC,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC1B,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpC,OAAO,CAAC,IAAI,CAAC;YACX,MAAM,EAAE,GAAG;YACX,OAAO,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;YAC5B,QAAQ,EAAE,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC;YACnC,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,EAAE;SAC9B,CAAC,CAAC;IACL,CAAC;IAED,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAClE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY,CAAC,QAAkB;IAC7C,MAAM,UAAU,GAA2B,EAAE,CAAC;IAC9C,MAAM,QAAQ,GAA2B,EAAE,CAAC;IAC5C,MAAM,QAAQ,GAA2B,EAAE,CAAC;IAC5C,MAAM,WAAW,GAA2B,EAAE,CAAC;IAC/C,IAAI,eAAe,GAAG,CAAC,CAAC;IACxB,IAAI,MAAM,GAAkB,IAAI,CAAC;IACjC,IAAI,MAAM,GAAkB,IAAI,CAAC;IACjC,IAAI,OAAO,GAAkB,IAAI,CAAC;IAElC,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,MAAM,EAAE,GAAG,CAAC,CAAC,WAAW,CAAC;QAEzB,UAAU,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QAC7D,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACrD,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACrD,WAAW,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACjE,eAAe,IAAI,EAAE,CAAC,UAAU,CAAC;QAEjC,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC,OAAO,GAAG,MAAM;YAAE,MAAM,GAAG,EAAE,CAAC,OAAO,CAAC;QACxD,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC,OAAO,GAAG,MAAM;YAAE,MAAM,GAAG,EAAE,CAAC,OAAO,CAAC;QACxD,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC,QAAQ,GAAG,OAAO;YAAE,OAAO,GAAG,EAAE,CAAC,QAAQ,CAAC;IAC/D,CAAC;IAED,OAAO;QACL,UAAU,EAAE,QAAQ,CAAC,MAAM;QAC3B,UAAU;QACV,QAAQ;QACR,QAAQ;QACR,WAAW;QACX,iBAAiB,EAAE,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QACxG,aAAa,EAAE,MAAM;QACrB,aAAa,EAAE,MAAM;QACrB,YAAY,EAAE,OAAO;KACtB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAAC,OAAkC,EAAE,MAAkB;IACzE,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAE1B,4CAA4C;IAC5C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAElC,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAChC,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACjC,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAE/B,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,KAAK;YACR,OAAO,OAAO,CAAC,CAAC,qBAAqB;QACvC,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,MAAM,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;YACzC,MAAM,OAAO,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;YAC9B,OAAO,GAAG,IAAI,KAAK,MAAM,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;QACxD,CAAC;QACD,KAAK,OAAO;YACV,OAAO,GAAG,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;QACrD,KAAK,MAAM;YACT,OAAO,GAAG,IAAI,EAAE,CAAC;IACrB,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,UAAU,CAAC,CAAO;IACzB,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IACnC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC7D,MAAM,KAAK,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACjD,OAAO,CACL,CAAC;QACD,IAAI,CAAC,KAAK,CACR,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,GAAG,QAAQ,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CACrF,CACF,CAAC;AACJ,CAAC"}

package/dist/lib/trace.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Gnosys Process Tracing — Phase 10
+ *
+ * Builds call chains from TypeScript/JavaScript source files and stores them
+ * as procedural "how" memories with relationship chaining:
+ *   - follows_from: sequential call order
+ *   - requires: dependency / import relationships
+ *   - leads_to: what this function calls
+ *
+ * No external dependencies beyond Node built-ins and the Gnosys DB.
+ */
+import { GnosysDB } from "./db.js";
+export interface TraceNode {
+    name: string;
+    file: string;
+    kind: "function" | "class" | "method" | "export";
+    line: number;
+    calls: string[];
+    calledBy: string[];
+    imports: string[];
+}
+export interface TraceGraph {
+    nodes: Map<string, TraceNode>;
+    files: string[];
+    rootDir: string;
+}
+export interface TraceResult {
+    memoriesCreated: number;
+    relationshipsCreated: number;
+    functionsFound: number;
+    filesScanned: number;
+    memoryIds: string[];
+}
+/**
+ * Trace a codebase directory: discover source files, parse function declarations
+ * and call relationships, then store as procedural "how" memories in the DB.
+ */
+export declare function traceCodebase(db: GnosysDB, rootDir: string, opts?: {
+    projectId?: string;
+    maxFiles?: number;
+}): TraceResult;
+//# sourceMappingURL=trace.d.ts.map

package/dist/lib/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/lib/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAE,QAAQ,EAAY,MAAM,SAAS,CAAC;AAI7C,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC9B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAwLD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,QAAQ,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,GAAE;IACJ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACd,GACL,WAAW,CAkKb"}

package/dist/lib/trace.js

@@ -0,0 +1,338 @@
+/**
+ * Gnosys Process Tracing — Phase 10
+ *
+ * Builds call chains from TypeScript/JavaScript source files and stores them
+ * as procedural "how" memories with relationship chaining:
+ *   - follows_from: sequential call order
+ *   - requires: dependency / import relationships
+ *   - leads_to: what this function calls
+ *
+ * No external dependencies beyond Node built-ins and the Gnosys DB.
+ */
+import fs from "fs";
+import path from "path";
+// ─── Source Parsing (Regex-based, no TS compiler dependency) ─────────
+/**
+ * Extract function declarations, class methods, exports, and call sites
+ * from a TypeScript/JavaScript source file using regex patterns.
+ *
+ * This is intentionally lightweight — no AST parsing dependency needed.
+ */
+function parseSourceFile(filePath, rootDir) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const relPath = path.relative(rootDir, filePath);
+    const nodes = [];
+    // Track imports for the file
+    const fileImports = [];
+    const importRegex = /import\s+(?:{[^}]*}|\*\s+as\s+\w+|\w+)\s+from\s+["']([^"']+)["']/g;
+    let importMatch;
+    while ((importMatch = importRegex.exec(content))) {
+        fileImports.push(importMatch[1]);
+    }
+    // Pattern: function declarations (named functions, arrow functions assigned to const/let/var)
+    const funcPatterns = [
+        // export function foo(...) or function foo(...)
+        /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/g,
+        // const foo = (...) => or const foo = function(...)
+        /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)\s*=>|function\s*\()/g,
+        // class methods: foo(...) { or async foo(...) {
+        /^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*[^{]+)?\s*\{/gm,
+    ];
+    // Pattern: class declarations
+    const classRegex = /(?:export\s+)?class\s+(\w+)(?:\s+(?:extends|implements)\s+\w+)?\s*\{/g;
+    // Extract function call sites: identifier followed by (
+    const callRegex = /\b(\w+)\s*\(/g;
+    // Common built-ins to exclude from call detection
+    const builtins = new Set([
+        "if", "for", "while", "switch", "catch", "return", "throw", "new", "typeof",
+        "instanceof", "delete", "void", "yield", "await", "import", "export",
+        "require", "console", "process", "JSON", "Object", "Array", "String",
+        "Number", "Boolean", "Map", "Set", "Promise", "Error", "Math", "Date",
+        "parseInt", "parseFloat", "setTimeout", "setInterval", "clearTimeout",
+        "clearInterval", "Buffer", "Symbol", "RegExp", "Proxy", "Reflect",
+        "describe", "it", "expect", "test", "beforeEach", "afterEach",
+    ]);
+    // First pass: find all function/class/method declarations
+    const declaredNames = new Set();
+    for (const pattern of funcPatterns) {
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(content))) {
+            const name = match[1];
+            if (builtins.has(name) || declaredNames.has(name))
+                continue;
+            declaredNames.add(name);
+            // Find line number
+            const lineNum = content.slice(0, match.index).split("\n").length;
+            nodes.push({
+                name,
+                file: relPath,
+                kind: "function",
+                line: lineNum,
+                calls: [],
+                calledBy: [],
+                imports: fileImports,
+            });
+        }
+    }
+    // Extract classes
+    {
+        classRegex.lastIndex = 0;
+        let match;
+        while ((match = classRegex.exec(content))) {
+            const name = match[1];
+            if (declaredNames.has(name))
+                continue;
+            declaredNames.add(name);
+            const lineNum = content.slice(0, match.index).split("\n").length;
+            nodes.push({
+                name,
+                file: relPath,
+                kind: "class",
+                line: lineNum,
+                calls: [],
+                calledBy: [],
+                imports: fileImports,
+            });
+        }
+    }
+    // Second pass: for each declared function, find what it calls
+    // This is an approximation — we scan the function body for call sites
+    for (const node of nodes) {
+        // Find the function body (from declaration to next top-level declaration or EOF)
+        const startLine = node.line - 1;
+        let endLine = lines.length;
+        // Simple heuristic: scan forward until we find the closing brace at the same indent level
+        let braceDepth = 0;
+        let foundOpen = false;
+        for (let i = startLine; i < lines.length; i++) {
+            for (const ch of lines[i]) {
+                if (ch === "{") {
+                    braceDepth++;
+                    foundOpen = true;
+                }
+                if (ch === "}") {
+                    braceDepth--;
+                }
+            }
+            if (foundOpen && braceDepth <= 0) {
+                endLine = i + 1;
+                break;
+            }
+        }
+        const body = lines.slice(startLine, endLine).join("\n");
+        callRegex.lastIndex = 0;
+        let callMatch;
+        const callSet = new Set();
+        while ((callMatch = callRegex.exec(body))) {
+            const callee = callMatch[1];
+            if (callee !== node.name && !builtins.has(callee) && declaredNames.has(callee)) {
+                callSet.add(callee);
+            }
+        }
+        node.calls = [...callSet];
+    }
+    // Back-fill calledBy
+    const nodeMap = new Map(nodes.map((n) => [n.name, n]));
+    for (const node of nodes) {
+        for (const callee of node.calls) {
+            const target = nodeMap.get(callee);
+            if (target) {
+                target.calledBy.push(node.name);
+            }
+        }
+    }
+    return nodes;
+}
+// ─── File Discovery ─────────────────────────────────────────────────────
+function discoverSourceFiles(rootDir) {
+    const files = [];
+    const extensions = new Set([".ts", ".js", ".tsx", ".jsx"]);
+    const ignoreDirs = new Set(["node_modules", "dist", "build", ".git", "coverage", ".gnosys"]);
+    function walk(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // Permission denied or other error
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") && entry.isDirectory())
+                continue;
+            if (ignoreDirs.has(entry.name) && entry.isDirectory())
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (entry.isFile() && extensions.has(path.extname(entry.name))) {
+                // Skip test files and declaration files
+                if (entry.name.endsWith(".test.ts") || entry.name.endsWith(".test.js"))
+                    continue;
+                if (entry.name.endsWith(".d.ts"))
+                    continue;
+                files.push(fullPath);
+            }
+        }
+    }
+    walk(rootDir);
+    return files;
+}
+// ─── Trace Codebase ─────────────────────────────────────────────────────
+/**
+ * Trace a codebase directory: discover source files, parse function declarations
+ * and call relationships, then store as procedural "how" memories in the DB.
+ */
+export function traceCodebase(db, rootDir, opts = {}) {
+    const absRoot = path.resolve(rootDir);
+    const sourceFiles = discoverSourceFiles(absRoot);
+    const filesToScan = opts.maxFiles
+        ? sourceFiles.slice(0, opts.maxFiles)
+        : sourceFiles;
+    // Parse all files
+    const allNodes = [];
+    for (const file of filesToScan) {
+        try {
+            const nodes = parseSourceFile(file, absRoot);
+            allNodes.push(...nodes);
+        }
+        catch {
+            // Skip unparseable files
+        }
+    }
+    if (allNodes.length === 0) {
+        return {
+            memoriesCreated: 0,
+            relationshipsCreated: 0,
+            functionsFound: 0,
+            filesScanned: filesToScan.length,
+            memoryIds: [],
+        };
+    }
+    // Build a global name→node map (deduplicate by file:name)
+    const globalMap = new Map();
+    for (const node of allNodes) {
+        const key = `${node.file}:${node.name}`;
+        globalMap.set(key, node);
+    }
+    // Cross-file: resolve calls to any declared function across files
+    const nameToKeys = new Map();
+    for (const [key, node] of globalMap) {
+        if (!nameToKeys.has(node.name))
+            nameToKeys.set(node.name, []);
+        nameToKeys.get(node.name).push(key);
+    }
+    const now = new Date().toISOString();
+    const memoryIds = [];
+    let relationshipsCreated = 0;
+    // Create a procedural memory for each function/class
+    const keyToMemId = new Map();
+    for (const [key, node] of globalMap) {
+        const memId = `mem-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        keyToMemId.set(key, memId);
+        const content = [
+            `## ${node.kind}: ${node.name}`,
+            "",
+            `**File:** \`${node.file}\` (line ${node.line})`,
+            "",
+            node.calls.length > 0
+                ? `**Calls:** ${node.calls.map((c) => `\`${c}\``).join(", ")}`
+                : "**Calls:** (none)",
+            node.calledBy.length > 0
+                ? `**Called by:** ${node.calledBy.map((c) => `\`${c}\``).join(", ")}`
+                : "**Called by:** (none)",
+            node.imports.length > 0
+                ? `\n**Imports:** ${node.imports.map((i) => `\`${i}\``).join(", ")}`
+                : "",
+        ].filter(Boolean).join("\n");
+        db.insertMemory({
+            id: memId,
+            title: `How: ${node.name} (${node.file})`,
+            category: "how",
+            content,
+            summary: null,
+            tags: JSON.stringify(["procedural", node.kind, path.basename(node.file, path.extname(node.file))]),
+            relevance: `how procedural ${node.name} ${node.file} ${node.kind}`,
+            author: "ai",
+            authority: "observed",
+            confidence: 0.85,
+            reinforcement_count: 0,
+            content_hash: "",
+            status: "active",
+            tier: "active",
+            supersedes: null,
+            superseded_by: null,
+            last_reinforced: null,
+            created: now,
+            modified: now,
+            embedding: null,
+            source_path: node.file,
+            project_id: opts.projectId || null,
+            scope: "project",
+        });
+        memoryIds.push(memId);
+    }
+    // Create relationships: leads_to, follows_from, requires
+    for (const [key, node] of globalMap) {
+        const sourceMemId = keyToMemId.get(key);
+        for (const callee of node.calls) {
+            // Find target memory IDs for this callee name
+            const targetKeys = nameToKeys.get(callee) || [];
+            for (const targetKey of targetKeys) {
+                const targetMemId = keyToMemId.get(targetKey);
+                if (!targetMemId || targetMemId === sourceMemId)
+                    continue;
+                // leads_to: this function leads to the callee
+                db.insertRelationship({
+                    source_id: sourceMemId,
+                    target_id: targetMemId,
+                    rel_type: "leads_to",
+                    label: `${node.name} calls ${callee}`,
+                    confidence: 0.9,
+                    created: now,
+                });
+                relationshipsCreated++;
+                // follows_from: the callee follows from this function
+                db.insertRelationship({
+                    source_id: targetMemId,
+                    target_id: sourceMemId,
+                    rel_type: "follows_from",
+                    label: `${callee} is called by ${node.name}`,
+                    confidence: 0.9,
+                    created: now,
+                });
+                relationshipsCreated++;
+            }
+        }
+        // requires: import relationships (module-level)
+        for (const imp of node.imports) {
+            // Find any nodes from the imported module
+            for (const [targetKey, targetNode] of globalMap) {
+                if (targetNode.file.includes(imp.replace(/^\.\//, "").replace(/\.\w+$/, ""))) {
+                    const targetMemId = keyToMemId.get(targetKey);
+                    if (!targetMemId || targetMemId === sourceMemId)
+                        continue;
+                    db.insertRelationship({
+                        source_id: sourceMemId,
+                        target_id: targetMemId,
+                        rel_type: "requires",
+                        label: `${node.file} imports from ${targetNode.file}`,
+                        confidence: 0.7,
+                        created: now,
+                    });
+                    relationshipsCreated++;
+                }
+            }
+        }
+    }
+    return {
+        memoriesCreated: memoryIds.length,
+        relationshipsCreated,
+        functionsFound: allNodes.length,
+        filesScanned: filesToScan.length,
+        memoryIds,
+    };
+}
+//# sourceMappingURL=trace.js.map