@kentwynn/kgraph 0.2.23 → 0.2.24

package/dist/cli/commands/knowledge.js

@@ -1,5 +1,7 @@
-import { readKnowledgeAtoms, updateKnowledgeAtom, } from '../../knowledge/atom-store.js';
+import { atomToCognitionNote, readKnowledgeAtoms, updateKnowledgeAtom, } from '../../knowledge/atom-store.js';
+import { rebuildDomainRecords } from '../../cognition/domain-records.js';
 import { assertWorkspace } from '../../storage/kgraph-paths.js';
+import { readMaps } from '../../storage/map-store.js';
 import { KGraphError, runCommand } from '../errors.js';
 export function registerKnowledgeCommand(program) {
     const knowledge = program
@@ -70,6 +72,7 @@ export function registerKnowledgeCommand(program) {
             provenance: { ...current.provenance, updatedAt: now },
             lifecycle: { ...current.lifecycle, archivedAt: now },
         }));
+        await rebuildActiveDomainRecords(workspace);
         console.log(options.json
             ? JSON.stringify(atom, null, 2)
             : `Archived knowledge atom: ${atom.id}`);
@@ -99,12 +102,23 @@ export function registerKnowledgeCommand(program) {
                 supersedes: [...new Set([...current.lifecycle.supersedes, oldId])],
             },
         }));
+        await rebuildActiveDomainRecords(workspace);
         const result = { old: oldAtom, new: newAtom };
         console.log(options.json
             ? JSON.stringify(result, null, 2)
             : `Superseded ${oldId} with ${newId}`);
     }));
 }
+async function rebuildActiveDomainRecords(workspace) {
+    const maps = await readMaps(workspace);
+    const activeNotes = (await readKnowledgeAtoms(workspace))
+        .filter((atom) => atom.status !== 'archived')
+        .map(atomToCognitionNote);
+    await rebuildDomainRecords(workspace, activeNotes, {
+        files: maps.fileMap.files,
+        symbols: maps.symbolMap.symbols,
+    });
+}
 async function requireAtom(workspace, atomId) {
     const atom = (await readKnowledgeAtoms(workspace)).find((candidate) => candidate.id === atomId);
     if (!atom)

package/dist/cognition/cognition-quality.js

@@ -26,7 +26,7 @@ export async function analyzeCognitionQuality(workspace, maps) {
         noisySymbolRefCount: changes.reduce((total, change) => total + change.removedSymbolRefs.length, 0),
         unresolvedLocalImportCount: countUnresolvedLocalImports(maps.dependencyMap),
         unresolvedCallCount: countUnresolvedCalls(maps.symbolMap, maps.relationshipMap),
-        duplicateTitleCount: countDuplicateAtomTopics(activeAtoms),
+        duplicateTitleCount: countDuplicateTitles(notes),
         generatedFileScanCount: countGeneratedScannedFiles(maps.fileMap),
         expensiveFileCount: countExpensiveFiles(maps.fileMap),
         highConfidenceMissingEvidenceCount: countHighConfidenceMissingEvidence(activeAtoms),
@@ -148,13 +148,23 @@ export async function repairCognition(workspace, maps, dryRun = false) {
     };
 }
 function countUnresolvedLocalImports(dependencyMap) {
-    return (dependencyMap?.dependencies.filter((dependency) => dependency.kind === 'local' && !dependency.resolvedFile).length ?? 0);
+    return (dependencyMap?.dependencies.filter((dependency) => dependency.kind === 'local' &&
+        !dependency.resolvedFile &&
+        isActionableUnresolvedLocalImport(dependency)).length ?? 0);
+}
+function isActionableUnresolvedLocalImport(dependency) {
+    if (dependency.fromFile.endsWith('/next-env.d.ts') &&
+        dependency.specifier.includes('.next/')) {
+        return false;
+    }
+    return true;
 }
 function countUnresolvedCalls(symbolMap, relationshipMap) {
     const symbolIds = new Set(symbolMap.symbols.map((symbol) => symbol.id));
     const symbolNames = new Set(symbolMap.symbols.map((symbol) => symbol.name));
     return (relationshipMap?.relationships.filter((relationship) => relationship.relationshipType === 'calls' &&
         relationship.targetType === 'symbol' &&
+        relationship.confidence !== 'low' &&
         !symbolIds.has(relationship.targetId) &&
         !symbolNames.has(relationship.targetId) &&
         ![...symbolNames].some((name) => relationship.targetId.endsWith(`#${name}`))).length ?? 0);
@@ -176,12 +186,8 @@ function countDuplicateAtomTopics(atoms) {
     const seen = new Set();
     const duplicates = new Set();
     for (const atom of atoms) {
-        const key = [
-            atom.type,
-            atom.topic.trim().toLowerCase(),
-            atom.claim.trim().toLowerCase(),
-        ].join('\0');
-        if (!atom.topic.trim())
+        const key = atom.topic.trim().toLowerCase();
+        if (!key)
             continue;
         if (seen.has(key))
             duplicates.add(key);

package/dist/cognition/compact.js

@@ -1,7 +1,8 @@
 import { mkdir, rename } from 'node:fs/promises';
 import path from 'node:path';
 import { atomToCognitionNote, refreshKnowledgeAtomStatuses, writeKnowledgeAtoms, } from '../knowledge/atom-store.js';
-import { overwriteDomainRecord, readDomainRecords, slugify, writeCognitionNote, } from '../storage/cognition-store.js';
+import { rebuildDomainRecords } from './domain-records.js';
+import { slugify, writeCognitionNote, } from '../storage/cognition-store.js';
 import { pathExists } from '../storage/kgraph-paths.js';
 import { readMaps } from '../storage/map-store.js';
 import { evaluateReferenceStatus } from './cognition-updater.js';
@@ -194,34 +195,6 @@ function mergeNotes(notes, currentMaps) {
         referencesStatus: evaluateReferenceStatus(relatedFiles, relatedSymbols, currentMaps),
     };
 }
-async function rebuildDomainRecords(workspace, notes, currentMaps) {
-    const existingDomains = await readDomainRecords(workspace);
-    const existingByName = new Map(existingDomains.map((domain) => [domain.name, domain]));
-    const domainNames = new Set([
-        ...existingDomains.map((domain) => domain.name),
-        ...notes.map((note) => note.domain ?? 'general'),
-    ]);
-    const fileSet = new Set(currentMaps.files.map((file) => file.path));
-    const symbolSet = new Set(currentMaps.symbols.map((symbol) => symbol.name));
-    for (const name of domainNames) {
-        const relatedNotes = notes.filter((note) => (note.domain ?? 'general') === name);
-        const existing = existingByName.get(name);
-        const next = {
-            name,
-            description: existing?.description,
-            pathHints: unique(relatedNotes.flatMap((note) => note.relatedFiles)),
-            tags: unique(relatedNotes.flatMap((note) => note.tags)),
-            files: unique(relatedNotes
-                .flatMap((note) => note.relatedFiles)
-                .filter((file) => fileSet.has(file))),
-            symbols: unique(relatedNotes
-                .flatMap((note) => note.relatedSymbols)
-                .filter((symbol) => symbolSet.has(symbol))),
-            cognitionNotes: relatedNotes.map((note) => note.id),
-        };
-        await overwriteDomainRecord(workspace, next);
-    }
-}
 async function archiveNote(workspace, note, reason) {
     const source = path.join(workspace.cognitionPath, `${note.id}.md`);
     if (!(await pathExists(source)))

package/dist/cognition/conclusion.js

@@ -67,7 +67,7 @@ export async function concludeTopic(workspace, input) {
         agent: input.agent,
         sessionId: input.sessionId,
         createdAt: note.createdAt,
-        idSeed: note.id,
+        idSeed: title,
     }, maps);
     return note;
 }

package/dist/cognition/domain-records.d.ts

@@ -0,0 +1,4 @@
+import type { KGraphWorkspace } from '../types/config.js';
+import type { CognitionNote } from '../types/cognition.js';
+import type { ScanResult } from '../types/maps.js';
+export declare function rebuildDomainRecords(workspace: KGraphWorkspace, notes: CognitionNote[], currentMaps: Pick<ScanResult, 'files' | 'symbols'>): Promise<void>;

package/dist/cognition/domain-records.js

@@ -0,0 +1,32 @@
+import { overwriteDomainRecord, readDomainRecords, } from '../storage/cognition-store.js';
+export async function rebuildDomainRecords(workspace, notes, currentMaps) {
+    const existingDomains = await readDomainRecords(workspace);
+    const existingByName = new Map(existingDomains.map((domain) => [domain.name, domain]));
+    const domainNames = new Set([
+        ...existingDomains.map((domain) => domain.name),
+        ...notes.map((note) => note.domain ?? 'general'),
+    ]);
+    const fileSet = new Set(currentMaps.files.map((file) => file.path));
+    const symbolSet = new Set(currentMaps.symbols.map((symbol) => symbol.name));
+    for (const name of domainNames) {
+        const relatedNotes = notes.filter((note) => (note.domain ?? 'general') === name);
+        const existing = existingByName.get(name);
+        const next = {
+            name,
+            description: existing?.description,
+            pathHints: unique(relatedNotes.flatMap((note) => note.relatedFiles)),
+            tags: unique(relatedNotes.flatMap((note) => note.tags)),
+            files: unique(relatedNotes
+                .flatMap((note) => note.relatedFiles)
+                .filter((file) => fileSet.has(file))),
+            symbols: unique(relatedNotes
+                .flatMap((note) => note.relatedSymbols)
+                .filter((symbol) => symbolSet.has(symbol))),
+            cognitionNotes: relatedNotes.map((note) => note.id),
+        };
+        await overwriteDomainRecord(workspace, next);
+    }
+}
+function unique(items) {
+    return [...new Set(items)];
+}

package/dist/config/config.js

@@ -7,6 +7,10 @@ export const DEFAULT_CONFIG = {
     exclude: [
         '.git',
         'node_modules',
+        'venv',
+        '.venv',
+        '__pycache__',
+        '.pytest_cache',
         'dist',
         'build',
         '.next',

package/dist/knowledge/atom-store.js

@@ -423,7 +423,7 @@ function buildIndexes(atoms) {
     const terms = {};
     const refs = {};
     const topics = {};
-    for (const atom of atoms) {
+    for (const atom of atoms.filter((item) => item.status !== 'archived')) {
         for (const term of tokenize([atom.topic, atom.claim, atom.summary ?? ''].join(' '))) {
             addIndex(terms, term, atom.id);
         }

package/dist/scanner/git-utils.d.ts

@@ -12,6 +12,11 @@ export declare function getCurrentCommit(rootPath: string): Promise<string | nul
  * Returns an empty array if git is unavailable or the ref is unknown.
  */
 export declare function getChangedFilesSince(rootPath: string, ref: string): Promise<string[]>;
+/**
+ * Returns the subset of paths ignored by Git, including nested .gitignore rules.
+ * Falls back to an empty set when Git is unavailable or the directory is not a repo.
+ */
+export declare function getGitIgnoredFiles(rootPath: string, paths: string[]): Promise<Set<string>>;
 /**
  * Returns paths of files with uncommitted changes (staged or unstaged)
  * relative to HEAD. Returns an empty array if git is unavailable.

package/dist/scanner/git-utils.js

@@ -1,4 +1,4 @@
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { access } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
@@ -47,6 +47,38 @@ export async function getChangedFilesSince(rootPath, ref) {
         return [];
     }
 }
+/**
+ * Returns the subset of paths ignored by Git, including nested .gitignore rules.
+ * Falls back to an empty set when Git is unavailable or the directory is not a repo.
+ */
+export async function getGitIgnoredFiles(rootPath, paths) {
+    if (paths.length === 0) {
+        return new Set();
+    }
+    return new Promise((resolve) => {
+        const child = spawn('git', ['check-ignore', '--stdin'], {
+            cwd: rootPath,
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        let stdout = '';
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.on('error', () => resolve(new Set()));
+        child.on('close', (code) => {
+            if (code !== 0 && code !== 1) {
+                resolve(new Set());
+                return;
+            }
+            resolve(new Set(stdout
+                .split('\n')
+                .map((line) => line.trim())
+                .filter(Boolean)));
+        });
+        child.stdin.end(`${paths.join('\n')}\n`);
+    });
+}
 /**
  * Returns paths of files with uncommitted changes (staged or unstaged)
  * relative to HEAD. Returns an empty array if git is unavailable.

package/dist/scanner/repo-scanner.js

@@ -7,7 +7,7 @@ import { extractBroadSymbols, supportsBroadExtraction, } from './broad-symbol-ex
 import { extractCSymbols } from './c-symbol-extractor.js';
 import { extractCSharpSymbols } from './csharp-symbol-extractor.js';
 import { buildFastGlobIgnore, detectLanguage, isPreciseLanguage, readGitignorePatterns, shouldExclude, } from './file-classifier.js';
-import { getChangedFilesSince, isGitRepo } from './git-utils.js';
+import { getChangedFilesSince, getGitIgnoredFiles, isGitRepo, } from './git-utils.js';
 import { extractGoSymbols } from './go-symbol-extractor.js';
 import { extractJvmSymbols } from './jvm-symbol-extractor.js';
 import { extractPhpSymbols } from './php-symbol-extractor.js';
@@ -65,13 +65,17 @@ export async function scanRepository(rootPath, config, previous) {
     const gitignorePatterns = await readGitignorePatterns(rootPath);
     const allExcludes = [...config.exclude, ...gitignorePatterns];
     const mergedConfig = { ...config, exclude: allExcludes };
-    const entries = await fg(config.include, {
+    const rawEntries = await fg(config.include, {
         cwd: rootPath,
         dot: true,
         onlyFiles: true,
         unique: true,
         ignore: buildFastGlobIgnore(allExcludes),
     });
+    const gitIgnored = (await isGitRepo(rootPath))
+        ? await getGitIgnoredFiles(rootPath, rawEntries)
+        : new Set();
+    const entries = rawEntries.filter((entry) => !gitIgnored.has(entry));
     // Build lookup maps from previous scan for incremental skip
     const prevFileByPath = new Map((previous?.files ?? []).map((f) => [f.path, f]));
     const prevSymbolsByFile = new Map();
@@ -215,7 +219,7 @@ export async function scanRepository(rootPath, config, previous) {
     }
     resolveLocalDependencies(dependencies, files);
     relationships.push(...buildImportRelationships(dependencies));
-    relationships.push(...detectMovedFiles(previous?.files ?? [], files));
+    relationships.push(...detectMovedFiles((previous?.files ?? []).filter((file) => !shouldExclude(file.path, mergedConfig)), files));
     return {
         files,
         symbols,
@@ -271,6 +275,9 @@ function resolveLocalDependencyPath(fromFile, specifier, filePaths) {
     if (!specifier.startsWith('.')) {
         return undefined;
     }
+    if (path.posix.extname(fromFile) === '.py') {
+        return resolvePythonRelativeImportPath(fromFile, specifier, filePaths);
+    }
     const base = path.posix.normalize(path.posix.join(path.posix.dirname(fromFile), specifier));
     const candidates = path.posix.extname(base)
         ? [base]
@@ -280,6 +287,26 @@ function resolveLocalDependencyPath(fromFile, specifier, filePaths) {
         ];
     return candidates.find((candidate) => filePaths.has(candidate));
 }
+function resolvePythonRelativeImportPath(fromFile, specifier, filePaths) {
+    const match = specifier.match(/^(\.+)(.*)$/);
+    if (!match) {
+        return undefined;
+    }
+    const [, dots, moduleName] = match;
+    const packageParts = path.posix.dirname(fromFile).split('/');
+    const levelsUp = Math.max(0, dots.length - 1);
+    const baseParts = levelsUp > 0 ? packageParts.slice(0, -levelsUp) : packageParts;
+    const modulePath = moduleName
+        .split('.')
+        .filter(Boolean)
+        .join('/');
+    const base = path.posix.normalize(path.posix.join(...baseParts, modulePath));
+    const candidates = [
+        `${base}.py`,
+        path.posix.join(base, '__init__.py'),
+    ];
+    return candidates.find((candidate) => filePaths.has(candidate));
+}
 function buildImportRelationships(dependencies) {
     return dependencies.map((dependency) => ({
         sourceType: 'file',

package/package.json

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