llm-wiki-kit 0.1.5 → 0.1.7

package/src/consolidate.js

@@ -0,0 +1,203 @@
+import { join } from 'path';
+import { appendWikiLog } from './project.js';
+import { backupFile, exists, readText, writeText } from './fs-utils.js';
+import { hasSecretLikeText, isSensitivePath, normalizeForStorage } from './redaction.js';
+import { indexPage, memoryPage } from './templates.js';
+import { collectWikiPages } from './wiki-model.js';
+import { runLint } from './wiki-lint.js';
+
+export const MEMORY_START = '<!-- llm-wiki-kit:memory-start -->';
+export const MEMORY_END = '<!-- llm-wiki-kit:memory-end -->';
+export const INDEX_START = '<!-- llm-wiki-kit:index-start -->';
+export const INDEX_END = '<!-- llm-wiki-kit:index-end -->';
+
+function replaceOrAppendBlock(content, startMarker, endMarker, block) {
+  const replacement = `${startMarker}\n${block.trim()}\n${endMarker}`;
+  const firstStart = content.indexOf(startMarker);
+  const firstEnd = content.indexOf(endMarker);
+  if (firstStart === -1 && firstEnd === -1) {
+    return { next: `${content.trimEnd()}\n\n${replacement}\n`, malformed: false };
+  }
+  const lastStart = content.lastIndexOf(startMarker);
+  const lastEnd = content.lastIndexOf(endMarker);
+  if (firstStart === -1 || firstEnd === -1 || firstEnd < firstStart || lastStart > lastEnd) {
+    return { next: content, malformed: true };
+  }
+  return {
+    next: `${content.slice(0, firstStart)}${replacement}${content.slice(lastEnd + endMarker.length)}`,
+    malformed: false,
+  };
+}
+
+function pageTarget(page) {
+  return page.rel.replace(/^wiki\//, '').replace(/\.md$/i, '');
+}
+
+function pageReference(page) {
+  return `[[${pageTarget(page)}|${page.title}]]`;
+}
+
+function importance(page) {
+  const value = Number(page.frontmatter.importance || 0);
+  return Number.isFinite(value) ? value : 0;
+}
+
+function isPromotableEpisodicPage(page) {
+  return ['semantic', 'procedural'].includes(page.memoryType) && importance(page) >= 4;
+}
+
+function isGeneratedBlockCandidate(page) {
+  if (['wiki/index.md', 'wiki/log.md', 'wiki/memory.md'].includes(page.rel)) return false;
+  if (isSensitivePath(page.rel) || isSensitivePath(page.title)) return false;
+  if (hasSecretLikeText(`${page.rel}\n${page.title}\n${page.content}`)) return false;
+  const type = String(page.type || '').toLowerCase();
+  if (
+    type === 'query' ||
+    type === 'context' ||
+    type === 'session-log' ||
+    page.rel.startsWith('wiki/queries/') ||
+    page.rel.startsWith('wiki/context/')
+  ) {
+    return isPromotableEpisodicPage(page);
+  }
+  return true;
+}
+
+function sortedPages(pages) {
+  return pages
+    .filter(isGeneratedBlockCandidate)
+    .sort((a, b) => {
+      const importanceDiff = importance(b) - importance(a);
+      if (importanceDiff !== 0) return importanceDiff;
+      const typeDiff = String(a.type || '').localeCompare(String(b.type || ''));
+      if (typeDiff !== 0) return typeDiff;
+      return a.rel.localeCompare(b.rel);
+    });
+}
+
+function buildGeneratedMemoryBlock(pages) {
+  const candidates = sortedPages(pages).slice(0, 25);
+  const lines = [
+    '## Generated Memory Map',
+    '',
+    `- Pages indexed: ${sortedPages(pages).length}`,
+  ];
+  if (candidates.length === 0) {
+    lines.push('- No durable pages found yet.');
+    return lines.join('\n');
+  }
+  lines.push('', '### High-Value Pages');
+  for (const page of candidates) {
+    const metadata = [
+      page.type || 'unknown',
+      page.memoryType ? `memory:${page.memoryType}` : '',
+      importance(page) > 0 ? `importance:${importance(page)}` : '',
+      page.confidence ? `confidence:${page.confidence}` : '',
+    ].filter(Boolean).join(', ');
+    lines.push(`- ${pageReference(page)}${metadata ? ` - ${metadata}` : ''}`);
+  }
+  return lines.join('\n');
+}
+
+function buildGeneratedIndexBlock(pages) {
+  const groups = new Map();
+  const candidates = sortedPages(pages);
+  for (const page of candidates) {
+    const type = page.type || 'uncategorized';
+    if (!groups.has(type)) groups.set(type, []);
+    groups.get(type).push(page);
+  }
+
+  const lines = [
+    '## Generated Page Map',
+    '',
+    `- Pages indexed: ${candidates.length}`,
+  ];
+  if (groups.size === 0) {
+    lines.push('- No durable pages found yet.');
+    return lines.join('\n');
+  }
+  for (const type of [...groups.keys()].sort()) {
+    lines.push('', `### ${type}`);
+    for (const page of groups.get(type).slice(0, 50)) {
+      lines.push(`- ${pageReference(page)}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+async function updateMarkedFile(projectRoot, rel, initialContent, startMarker, endMarker, block, options) {
+  const absolutePath = join(projectRoot, rel);
+  const current = await readText(absolutePath, initialContent);
+  const { next, malformed } = replaceOrAppendBlock(current || initialContent, startMarker, endMarker, block);
+  if (malformed) return { skipped: { path: rel, reason: 'malformed-marker' } };
+  if (normalizeForStorage(current) === normalizeForStorage(next)) return null;
+  if (!options.dryRun) {
+    if (await exists(absolutePath)) await backupFile(absolutePath, rel);
+    await writeText(absolutePath, next);
+  }
+  return { changed: { path: rel } };
+}
+
+export async function runConsolidate(projectRoot, options = {}) {
+  const lintResult = await runLint(projectRoot, { maxFiles: options.maxFiles || 1000 });
+  const pages = await collectWikiPages(projectRoot, { maxFiles: options.maxFiles || 1000 });
+  const changed = [];
+  const skipped = [];
+
+  const memoryChange = await updateMarkedFile(
+    projectRoot,
+    join('llm-wiki', 'wiki', 'memory.md'),
+    memoryPage(),
+    MEMORY_START,
+    MEMORY_END,
+    buildGeneratedMemoryBlock(pages),
+    options,
+  );
+  if (memoryChange?.changed) changed.push(memoryChange.changed);
+  if (memoryChange?.skipped) skipped.push(memoryChange.skipped);
+
+  const indexChange = await updateMarkedFile(
+    projectRoot,
+    join('llm-wiki', 'wiki', 'index.md'),
+    indexPage(),
+    INDEX_START,
+    INDEX_END,
+    buildGeneratedIndexBlock(pages),
+    options,
+  );
+  if (indexChange?.changed) changed.push(indexChange.changed);
+  if (indexChange?.skipped) skipped.push(indexChange.skipped);
+
+  const finalLintResult = options.dryRun || changed.length === 0
+    ? lintResult
+    : await runLint(projectRoot, { maxFiles: options.maxFiles || 1000 });
+
+  if (changed.length > 0 && !options.dryRun) {
+    await appendWikiLog(projectRoot, `consolidate: refreshed ${changed.map((item) => item.path).join(', ')}; lint errors=${finalLintResult.errorCount}; warnings=${finalLintResult.warningCount}`);
+  }
+
+  return {
+    workspace: projectRoot,
+    dryRun: Boolean(options.dryRun),
+    changed,
+    skipped,
+    lint: {
+      ok: finalLintResult.ok,
+      errorCount: finalLintResult.errorCount,
+      warningCount: finalLintResult.warningCount,
+    },
+  };
+}
+
+export function formatConsolidateResult(result) {
+  return [
+    'llm-wiki consolidate',
+    `- workspace: ${result.workspace}`,
+    `- dry run: ${result.dryRun ? 'yes' : 'no'}`,
+    `- changed: ${result.changed.length ? result.changed.map((item) => item.path).join(', ') : 'none'}`,
+    `- skipped: ${result.skipped?.length ? result.skipped.map((item) => `${item.path} (${item.reason})`).join(', ') : 'none'}`,
+    `- lint errors: ${result.lint.errorCount}`,
+    `- lint warnings: ${result.lint.warningCount}`,
+  ].join('\n');
+}

package/src/hook.js

@@ -3,7 +3,8 @@ import { bootstrapProject, appendContextNote, appendLiveQa, appendSessionEnvelop
 import { applyProjectTemplateUpdate, inspectProjectState } from './project-state.js';
 import { recordProject } from './projects.js';
 import { summarizeForStorage } from './redaction.js';
-import { buildEntryFromState, rememberQuestion, rememberTool } from './state.js';
+import { buildEntryFromState, clearTurnState, rememberQuestion, rememberTool } from './state.js';
+import { relative } from 'path';
 
 async function readStdinJson() {
   const chunks = [];
@@ -45,7 +46,9 @@ async function autoUpdateManagedProject(projectRoot, eventName) {
   const state = await inspectProjectState(projectRoot);
   if (state.runtimeUpToDateWithProject && state.managedFilesCurrent) return;
   const result = await applyProjectTemplateUpdate(projectRoot);
-  await appendWikiLog(projectRoot, `llm-wiki-kit auto-update applied runtime ${result.runtimeVersion}; changed templates: ${result.changed.length}; skipped templates: ${result.skipped.length}`);
+  if (result.changed.length > 0) {
+    await appendWikiLog(projectRoot, `llm-wiki-kit auto-update applied runtime ${result.runtimeVersion}; changed templates: ${result.changed.length}; skipped templates: ${result.skipped.length}`);
+  }
 }
 
 export async function handleHook(provider, explicitEvent) {
@@ -96,7 +99,10 @@ export async function handleHook(provider, explicitEvent) {
       await appendLiveQa(projectRoot, entry);
       const queryPath = await writeQueryPage(projectRoot, entry);
       const decisionPath = await writeDecisionPage(projectRoot, entry);
-      await appendWikiLog(projectRoot, `captured ${eventName}${queryPath ? `; query=${queryPath}` : ''}${decisionPath ? `; decision=${decisionPath}` : ''}`);
+      await appendWikiLog(projectRoot, `captured ${eventName}${queryPath ? `; query=${relative(projectRoot, queryPath)}` : ''}${decisionPath ? `; decision=${relative(projectRoot, decisionPath)}` : ''}`);
+    }
+    if (eventName === 'Stop' || eventName === 'SessionEnd') {
+      await clearTurnState(projectRoot, payload).catch(() => {});
     }
     return {};
   }

package/src/install.js

@@ -78,8 +78,10 @@ export async function install(options = {}) {
     await backupFile(localBinPath, 'local-bin-llm-wiki');
   }
   await safeSymlink(binPath, localBinPath);
-  await bootstrapProject(workspace, { profile: options.profile || 'standard', recordState: true });
-  await recordProject(workspace, 'install');
+  if (!options.noProject) {
+    await bootstrapProject(workspace, { profile: options.profile || 'standard', recordState: true });
+    await recordProject(workspace, 'install');
+  }
 
   const codexHooksPath = join(homeDir(), '.codex', 'hooks.json');
   const claudeSettingsPath = join(homeDir(), '.claude', 'settings.json');