@kentwynn/kgraph 0.1.14 → 0.1.15

package/dist/cognition/cognition-updater.d.ts

@@ -1,10 +1,10 @@
-import type { KGraphWorkspace } from "../types/config.js";
-import type { CognitionNote, ReferenceStatus } from "../types/cognition.js";
-import type { ScanResult } from "../types/maps.js";
+import type { CognitionNote, ReferenceStatus } from '../types/cognition.js';
+import type { KGraphWorkspace } from '../types/config.js';
+import type { ScanResult } from '../types/maps.js';
 export interface UpdateResult {
     processed: CognitionNote[];
     warnings: string[];
 }
-export declare function updateCognition(workspace: KGraphWorkspace, currentMaps: Pick<ScanResult, "files" | "symbols">, dryRun?: boolean): Promise<UpdateResult>;
-export declare function refreshCognitionReferenceStatuses(workspace: KGraphWorkspace, currentMaps: Pick<ScanResult, "files" | "symbols">): Promise<void>;
-export declare function evaluateReferenceStatus(relatedFiles: string[], relatedSymbols: string[], currentMaps: Pick<ScanResult, "files" | "symbols">): ReferenceStatus;
+export declare function updateCognition(workspace: KGraphWorkspace, currentMaps: Pick<ScanResult, 'files' | 'symbols'>, dryRun?: boolean): Promise<UpdateResult>;
+export declare function refreshCognitionReferenceStatuses(workspace: KGraphWorkspace, currentMaps: Pick<ScanResult, 'files' | 'symbols'>): Promise<void>;
+export declare function evaluateReferenceStatus(relatedFiles: string[], relatedSymbols: string[], currentMaps: Pick<ScanResult, 'files' | 'symbols'>): ReferenceStatus;

package/dist/cognition/cognition-updater.js

@@ -1,25 +1,31 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { parseMarkdownNote } from "./markdown-note-parser.js";
-import { archiveInboxNote, readCognitionNotes, listInboxNotes, slugify, writeCognitionNote, writeDomainRecord } from "../storage/cognition-store.js";
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { archiveInboxNote, listInboxNotes, readCognitionNotes, slugify, writeCognitionNote, writeDomainRecord, } from '../storage/cognition-store.js';
+import { parseMarkdownNote } from './markdown-note-parser.js';
 export async function updateCognition(workspace, currentMaps, dryRun = false) {
     const inboxNotes = await listInboxNotes(workspace);
     const processed = [];
     const warnings = [];
     for (const inboxPath of inboxNotes) {
         try {
-            const raw = await readFile(inboxPath, "utf8");
+            const raw = await readFile(inboxPath, 'utf8');
             const parsed = parseMarkdownNote(raw);
-            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-            const id = `${timestamp}-${slugify(parsed.title) || path.basename(inboxPath, ".md")}`;
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const id = `${timestamp}-${slugify(parsed.title) || path.basename(inboxPath, '.md')}`;
             const archivedPath = path.join(workspace.processedInteractionsPath, `${timestamp}-${path.basename(inboxPath)}`);
             const note = {
                 ...parsed,
                 id,
-                sourceInboxPath: path.relative(workspace.rootPath, inboxPath).split(path.sep).join("/"),
-                processedPath: path.relative(workspace.rootPath, archivedPath).split(path.sep).join("/"),
+                sourceInboxPath: path
+                    .relative(workspace.rootPath, inboxPath)
+                    .split(path.sep)
+                    .join('/'),
+                processedPath: path
+                    .relative(workspace.rootPath, archivedPath)
+                    .split(path.sep)
+                    .join('/'),
                 createdAt: new Date().toISOString(),
-                referencesStatus: evaluateReferenceStatus(parsed.relatedFiles, parsed.relatedSymbols, currentMaps)
+                referencesStatus: evaluateReferenceStatus(parsed.relatedFiles, parsed.relatedSymbols, currentMaps),
             };
             processed.push(note);
             warnings.push(...parsed.warnings.map((warning) => `${path.basename(inboxPath)}: ${warning}`));
@@ -38,9 +44,28 @@ export async function updateCognition(workspace, currentMaps, dryRun = false) {
 export async function refreshCognitionReferenceStatuses(workspace, currentMaps) {
     const notes = await readCognitionNotes(workspace);
     for (const note of notes) {
-        const nextStatus = evaluateReferenceStatus(note.relatedFiles, note.relatedSymbols, currentMaps);
-        if (nextStatus !== note.referencesStatus) {
-            await writeCognitionNote(workspace, { ...note, referencesStatus: nextStatus });
+        // Re-parse relatedSymbols from the archived raw markdown if available.
+        // This migrates old notes that were parsed with the old plain-text heuristic
+        // (which produced false positives like JWT, CSRF, TODO) to the current
+        // backtick-only logic.
+        let relatedSymbols = note.relatedSymbols;
+        if (note.processedPath) {
+            try {
+                const raw = await readFile(path.join(workspace.rootPath, note.processedPath), 'utf8');
+                relatedSymbols = parseMarkdownNote(raw).relatedSymbols;
+            }
+            catch {
+                // archived file missing — keep stored symbols
+            }
+        }
+        const nextStatus = evaluateReferenceStatus(note.relatedFiles, relatedSymbols, currentMaps);
+        if (nextStatus !== note.referencesStatus ||
+            relatedSymbols !== note.relatedSymbols) {
+            await writeCognitionNote(workspace, {
+                ...note,
+                relatedSymbols,
+                referencesStatus: nextStatus,
+            });
         }
     }
 }
@@ -49,21 +74,21 @@ export function evaluateReferenceStatus(relatedFiles, relatedSymbols, currentMap
     const symbolNames = new Set(currentMaps.symbols.map((symbol) => symbol.name));
     const references = [
         ...relatedFiles.map((file) => filePaths.has(file)),
-        ...relatedSymbols.map((symbol) => symbolNames.has(symbol))
+        ...relatedSymbols.map((symbol) => symbolNames.has(symbol)),
     ];
     if (references.length === 0) {
-        return "unresolved";
+        return 'unresolved';
     }
     if (references.every(Boolean)) {
-        return "current";
+        return 'current';
     }
     if (references.every((value) => !value)) {
-        return "stale";
+        return 'stale';
     }
-    return "mixed";
+    return 'mixed';
 }
 function toDomainRecord(note, currentMaps) {
-    const name = note.domain ?? "general";
+    const name = note.domain ?? 'general';
     const fileSet = new Set(currentMaps.files.map((file) => file.path));
     const symbolSet = new Set(currentMaps.symbols.map((symbol) => symbol.name));
     return {
@@ -72,6 +97,6 @@ function toDomainRecord(note, currentMaps) {
         tags: note.tags,
         files: note.relatedFiles.filter((file) => fileSet.has(file)),
         symbols: note.relatedSymbols.filter((symbol) => symbolSet.has(symbol)),
-        cognitionNotes: [note.id]
+        cognitionNotes: [note.id],
     };
 }

package/dist/cognition/markdown-note-parser.js

@@ -14,7 +14,7 @@ export function parseMarkdownNote(markdown) {
         summary: sections.Summary,
         sections,
         relatedFiles: unique(extractMatches(combined, PATH_REF)),
-        relatedSymbols: unique(extractSymbolRefs(combined)),
+        relatedSymbols: unique(extractSymbolRefs(sections)),
         warnings,
     };
 }
@@ -59,23 +59,12 @@ function parseSections(body) {
 function extractMatches(text, regex) {
     return [...text.matchAll(regex)].map((match) => match[1]);
 }
-function extractSymbolRefs(text) {
-    const stopwords = new Set([
-        'Summary',
-        'Related',
-        'Files',
-        'Functions',
-        'Decisions',
-        'Debugging',
-        'Conclusions',
-    ]);
-    // Backtick-quoted: accept any identifier in backticks
-    const backtickSymbols = [...text.matchAll(/`([A-Za-z_$][\w$]{2,})`/g)].map((m) => m[1]);
-    // Plain text: only camelCase, PascalCase, ALL_CAPS, or snake_case (must contain uppercase or underscore after first char)
-    const plainSymbols = [...text.matchAll(/\b([A-Za-z_$][\w$]{2,})\b/g)]
-        .map((m) => m[1])
-        .filter((item) => /[A-Z_]/.test(item.slice(1)));
-    return unique([...backtickSymbols, ...plainSymbols].filter((item) => !stopwords.has(item) && !item.includes('.')));
+function extractSymbolRefs(sections) {
+    // Prefer declared symbols in the Key Symbols section; fall back to backtick
+    // items across all sections. Never use plain-text heuristics — they produce
+    // false positives for domain vocabulary like JWT, CSRF, TODO, Next, etc.
+    const text = sections['Key Symbols'] ?? Object.values(sections).join('\n');
+    return [...text.matchAll(/`([A-Za-z_$][\w$]{2,})`/g)].map((m) => m[1]);
 }
 function unique(items) {
     return [...new Set(items)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kentwynn/kgraph",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {