@fermindi/pwn-cli 0.1.1 → 0.2.0

package/src/knowledge/gc.js

@@ -1,308 +1,308 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } from 'fs';
-import { join } from 'path';
-import {
-  getKnowledgeRegistry,
-  saveKnowledgeRegistry,
-  getAllKnowledge,
-  changeStatus
-} from './lifecycle.js';
-import { findBrokenReferences } from './references.js';
-
-/**
- * GC Result
- * @typedef {Object} GCResult
- * @property {string[]} marked - Items marked for deletion
- * @property {string[]} archived - Items archived
- * @property {string[]} deleted - Items removed
- * @property {string[]} cleaned - Broken references cleaned
- */
-
-/**
- * Identify items that should be garbage collected
- * Criteria:
- * - No related files exist
- * - No references from other decisions
- * - Status is 'garbage' or orphaned
- * @param {string} cwd - Working directory
- * @returns {Object[]} Items to collect
- */
-export function identifyGarbage(cwd = process.cwd()) {
-  const registry = getKnowledgeRegistry(cwd);
-  if (!registry) {
-    return [];
-  }
-
-  const garbage = [];
-
-  for (const [id, item] of Object.entries(registry.items)) {
-    // Already marked as garbage
-    if (item.status === 'garbage') {
-      garbage.push({
-        id,
-        title: item.title,
-        reason: 'marked_garbage',
-        relatedFiles: item.relatedFiles || [],
-        relatedDecisions: item.relatedDecisions || []
-      });
-      continue;
-    }
-
-    // Check if orphaned (no references)
-    const hasFileRefs = (item.relatedFiles || []).length > 0;
-    const hasDecisionRefs = (item.relatedDecisions || []).length > 0;
-    const hasTaskRefs = (item.relatedTasks || []).length > 0;
-
-    if (!hasFileRefs && !hasDecisionRefs && !hasTaskRefs) {
-      // Check if it's been accessed recently (last 30 days)
-      const lastAccessed = item.lastAccessed ? new Date(item.lastAccessed) : null;
-      const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
-
-      if (!lastAccessed || lastAccessed < thirtyDaysAgo) {
-        garbage.push({
-          id,
-          title: item.title,
-          reason: 'orphaned',
-          lastAccessed: item.lastAccessed,
-          relatedFiles: [],
-          relatedDecisions: []
-        });
-      }
-    }
-  }
-
-  return garbage;
-}
-
-/**
- * Run garbage collection in dry-run mode
- * @param {string} cwd - Working directory
- * @returns {GCResult}
- */
-export function dryRunGC(cwd = process.cwd()) {
-  const garbage = identifyGarbage(cwd);
-  const broken = findBrokenReferences(cwd);
-
-  return {
-    marked: garbage.map(g => g.id),
-    archived: [],
-    deleted: [],
-    cleaned: broken.map(b => b.id),
-    details: {
-      garbage,
-      broken
-    }
-  };
-}
-
-/**
- * Execute garbage collection
- * @param {Object} options - Options
- * @param {boolean} options.archive - Archive instead of delete
- * @param {boolean} options.cleanBroken - Clean broken references
- * @param {string} cwd - Working directory
- * @returns {GCResult}
- */
-export function executeGC(options = {}, cwd = process.cwd()) {
-  const { archive = true, cleanBroken = true } = options;
-  const registry = getKnowledgeRegistry(cwd);
-
-  if (!registry) {
-    return { marked: [], archived: [], deleted: [], cleaned: [] };
-  }
-
-  const result = {
-    marked: [],
-    archived: [],
-    deleted: [],
-    cleaned: []
-  };
-
-  // Identify garbage
-  const garbage = identifyGarbage(cwd);
-
-  for (const item of garbage) {
-    if (archive) {
-      // Archive to memory/archive
-      archiveKnowledgeItem(item.id, cwd);
-      // Update local registry reference to reflect archived status
-      registry.items[item.id].status = 'archived';
-      result.archived.push(item.id);
-    } else {
-      // Delete from registry
-      delete registry.items[item.id];
-      result.deleted.push(item.id);
-    }
-    result.marked.push(item.id);
-  }
-
-  // Clean broken references if requested
-  if (cleanBroken) {
-    const broken = findBrokenReferences(cwd);
-    for (const { id, brokenFiles, brokenDecisions } of broken) {
-      const item = registry.items[id];
-      if (item) {
-        // Remove broken file references
-        item.relatedFiles = (item.relatedFiles || []).filter(
-          f => !brokenFiles.includes(f)
-        );
-        // Remove broken decision references
-        item.relatedDecisions = (item.relatedDecisions || []).filter(
-          d => !brokenDecisions.includes(d)
-        );
-        result.cleaned.push(id);
-      }
-    }
-  }
-
-  // Update last GC timestamp
-  registry.lastGC = new Date().toISOString();
-  saveKnowledgeRegistry(registry, cwd);
-
-  return result;
-}
-
-/**
- * Archive a knowledge item to memory/archive
- * @param {string} id - Item ID
- * @param {string} cwd - Working directory
- */
-function archiveKnowledgeItem(id, cwd = process.cwd()) {
-  const registry = getKnowledgeRegistry(cwd);
-  if (!registry || !registry.items[id]) return;
-
-  const item = registry.items[id];
-  const archiveDir = join(cwd, '.ai', 'memory', 'archive');
-
-  // Ensure archive directory exists
-  if (!existsSync(archiveDir)) {
-    mkdirSync(archiveDir, { recursive: true });
-  }
-
-  // Append to archive file
-  const archiveFile = join(archiveDir, 'archived-knowledge.md');
-  const archiveEntry = formatArchiveEntry(item);
-
-  appendFileSync(archiveFile, archiveEntry);
-
-  // Update status in registry
-  registry.items[id].status = 'archived';
-  registry.items[id].archivedAt = new Date().toISOString();
-  saveKnowledgeRegistry(registry, cwd);
-}
-
-/**
- * Format a knowledge item for archive
- * @param {Object} item - Knowledge item
- * @returns {string}
- */
-function formatArchiveEntry(item) {
-  const divider = '\n---\n\n';
-  const header = `## ${item.id}: ${item.title} [ARCHIVED]\n`;
-  const metadata = [
-    `**Type:** ${item.type}`,
-    `**Created:** ${item.createdAt || 'Unknown'}`,
-    `**Archived:** ${new Date().toISOString().split('T')[0]}`,
-    `**Access Count:** ${item.accessCount || 0}`,
-    `**Applied Count:** ${item.appliedCount || 0}`,
-    `**Last Accessed:** ${item.lastAccessed || 'Never'}`
-  ].join('\n');
-
-  const refs = [];
-  if (item.relatedFiles?.length) {
-    refs.push(`**Related Files:** ${item.relatedFiles.join(', ')}`);
-  }
-  if (item.relatedDecisions?.length) {
-    refs.push(`**Related Decisions:** ${item.relatedDecisions.join(', ')}`);
-  }
-  if (item.appliedContexts?.length) {
-    refs.push(`**Applied Contexts:** ${item.appliedContexts.join(', ')}`);
-  }
-
-  return header + metadata + '\n' + refs.join('\n') + divider;
-}
-
-/**
- * Get items that are candidates for archival (inactive but not orphaned)
- * @param {number} inactiveDays - Days of inactivity
- * @param {string} cwd - Working directory
- * @returns {Object[]}
- */
-export function getArchivalCandidates(inactiveDays = 60, cwd = process.cwd()) {
-  const registry = getKnowledgeRegistry(cwd);
-  if (!registry) return [];
-
-  const candidates = [];
-  const cutoff = new Date(Date.now() - inactiveDays * 24 * 60 * 60 * 1000);
-
-  for (const [id, item] of Object.entries(registry.items)) {
-    if (item.status !== 'active') continue;
-
-    const lastAccessed = item.lastAccessed ? new Date(item.lastAccessed) : null;
-
-    // Has references but hasn't been accessed
-    const hasRefs = (item.relatedFiles || []).length > 0 ||
-                    (item.relatedDecisions || []).length > 0;
-
-    if (hasRefs && (!lastAccessed || lastAccessed < cutoff)) {
-      candidates.push({
-        id,
-        title: item.title,
-        lastAccessed: item.lastAccessed,
-        daysSinceAccess: lastAccessed
-          ? Math.floor((Date.now() - lastAccessed) / (24 * 60 * 60 * 1000))
-          : 'never',
-        refCount: (item.relatedFiles || []).length + (item.relatedDecisions || []).length
-      });
-    }
-  }
-
-  return candidates.sort((a, b) => {
-    const aDate = a.lastAccessed ? new Date(a.lastAccessed) : new Date(0);
-    const bDate = b.lastAccessed ? new Date(b.lastAccessed) : new Date(0);
-    return aDate - bDate;
-  });
-}
-
-/**
- * Restore an archived item back to active
- * @param {string} id - Item ID
- * @param {string} cwd - Working directory
- * @returns {Object|null}
- */
-export function restoreFromArchive(id, cwd = process.cwd()) {
-  const registry = getKnowledgeRegistry(cwd);
-  if (!registry || !registry.items[id]) return null;
-
-  const item = registry.items[id];
-  if (item.status !== 'archived') {
-    return { error: `Item ${id} is not archived (status: ${item.status})` };
-  }
-
-  item.status = 'active';
-  item.restoredAt = new Date().toISOString();
-  delete item.archivedAt;
-
-  saveKnowledgeRegistry(registry, cwd);
-  return item;
-}
-
-/**
- * Get GC statistics
- * @param {string} cwd - Working directory
- * @returns {Object}
- */
-export function getGCStats(cwd = process.cwd()) {
-  const registry = getKnowledgeRegistry(cwd);
-  const garbage = identifyGarbage(cwd);
-  const archivalCandidates = getArchivalCandidates(60, cwd);
-  const broken = findBrokenReferences(cwd);
-
-  return {
-    lastGC: registry?.lastGC || 'Never',
-    garbageCount: garbage.length,
-    archivalCandidates: archivalCandidates.length,
-    brokenReferences: broken.length,
-    garbage: garbage.map(g => ({ id: g.id, reason: g.reason })),
-    candidates: archivalCandidates.slice(0, 5)
-  };
-}
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join } from 'path';
+import {
+  getKnowledgeRegistry,
+  saveKnowledgeRegistry,
+  getAllKnowledge,
+  changeStatus
+} from './lifecycle.js';
+import { findBrokenReferences } from './references.js';
+
+/**
+ * GC Result
+ * @typedef {Object} GCResult
+ * @property {string[]} marked - Items marked for deletion
+ * @property {string[]} archived - Items archived
+ * @property {string[]} deleted - Items removed
+ * @property {string[]} cleaned - Broken references cleaned
+ */
+
+/**
+ * Identify items that should be garbage collected
+ * Criteria:
+ * - No related files exist
+ * - No references from other decisions
+ * - Status is 'garbage' or orphaned
+ * @param {string} cwd - Working directory
+ * @returns {Object[]} Items to collect
+ */
+export function identifyGarbage(cwd = process.cwd()) {
+  const registry = getKnowledgeRegistry(cwd);
+  if (!registry) {
+    return [];
+  }
+
+  const garbage = [];
+
+  for (const [id, item] of Object.entries(registry.items)) {
+    // Already marked as garbage
+    if (item.status === 'garbage') {
+      garbage.push({
+        id,
+        title: item.title,
+        reason: 'marked_garbage',
+        relatedFiles: item.relatedFiles || [],
+        relatedDecisions: item.relatedDecisions || []
+      });
+      continue;
+    }
+
+    // Check if orphaned (no references)
+    const hasFileRefs = (item.relatedFiles || []).length > 0;
+    const hasDecisionRefs = (item.relatedDecisions || []).length > 0;
+    const hasTaskRefs = (item.relatedTasks || []).length > 0;
+
+    if (!hasFileRefs && !hasDecisionRefs && !hasTaskRefs) {
+      // Check if it's been accessed recently (last 30 days)
+      const lastAccessed = item.lastAccessed ? new Date(item.lastAccessed) : null;
+      const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+
+      if (!lastAccessed || lastAccessed < thirtyDaysAgo) {
+        garbage.push({
+          id,
+          title: item.title,
+          reason: 'orphaned',
+          lastAccessed: item.lastAccessed,
+          relatedFiles: [],
+          relatedDecisions: []
+        });
+      }
+    }
+  }
+
+  return garbage;
+}
+
+/**
+ * Run garbage collection in dry-run mode
+ * @param {string} cwd - Working directory
+ * @returns {GCResult}
+ */
+export function dryRunGC(cwd = process.cwd()) {
+  const garbage = identifyGarbage(cwd);
+  const broken = findBrokenReferences(cwd);
+
+  return {
+    marked: garbage.map(g => g.id),
+    archived: [],
+    deleted: [],
+    cleaned: broken.map(b => b.id),
+    details: {
+      garbage,
+      broken
+    }
+  };
+}
+
+/**
+ * Execute garbage collection
+ * @param {Object} options - Options
+ * @param {boolean} options.archive - Archive instead of delete
+ * @param {boolean} options.cleanBroken - Clean broken references
+ * @param {string} cwd - Working directory
+ * @returns {GCResult}
+ */
+export function executeGC(options = {}, cwd = process.cwd()) {
+  const { archive = true, cleanBroken = true } = options;
+  const registry = getKnowledgeRegistry(cwd);
+
+  if (!registry) {
+    return { marked: [], archived: [], deleted: [], cleaned: [] };
+  }
+
+  const result = {
+    marked: [],
+    archived: [],
+    deleted: [],
+    cleaned: []
+  };
+
+  // Identify garbage
+  const garbage = identifyGarbage(cwd);
+
+  for (const item of garbage) {
+    if (archive) {
+      // Archive to memory/archive
+      archiveKnowledgeItem(item.id, cwd);
+      // Update local registry reference to reflect archived status
+      registry.items[item.id].status = 'archived';
+      result.archived.push(item.id);
+    } else {
+      // Delete from registry
+      delete registry.items[item.id];
+      result.deleted.push(item.id);
+    }
+    result.marked.push(item.id);
+  }
+
+  // Clean broken references if requested
+  if (cleanBroken) {
+    const broken = findBrokenReferences(cwd);
+    for (const { id, brokenFiles, brokenDecisions } of broken) {
+      const item = registry.items[id];
+      if (item) {
+        // Remove broken file references
+        item.relatedFiles = (item.relatedFiles || []).filter(
+          f => !brokenFiles.includes(f)
+        );
+        // Remove broken decision references
+        item.relatedDecisions = (item.relatedDecisions || []).filter(
+          d => !brokenDecisions.includes(d)
+        );
+        result.cleaned.push(id);
+      }
+    }
+  }
+
+  // Update last GC timestamp
+  registry.lastGC = new Date().toISOString();
+  saveKnowledgeRegistry(registry, cwd);
+
+  return result;
+}
+
+/**
+ * Archive a knowledge item to memory/archive
+ * @param {string} id - Item ID
+ * @param {string} cwd - Working directory
+ */
+function archiveKnowledgeItem(id, cwd = process.cwd()) {
+  const registry = getKnowledgeRegistry(cwd);
+  if (!registry || !registry.items[id]) return;
+
+  const item = registry.items[id];
+  const archiveDir = join(cwd, '.ai', 'memory', 'archive');
+
+  // Ensure archive directory exists
+  if (!existsSync(archiveDir)) {
+    mkdirSync(archiveDir, { recursive: true });
+  }
+
+  // Append to archive file
+  const archiveFile = join(archiveDir, 'archived-knowledge.md');
+  const archiveEntry = formatArchiveEntry(item);
+
+  appendFileSync(archiveFile, archiveEntry);
+
+  // Update status in registry
+  registry.items[id].status = 'archived';
+  registry.items[id].archivedAt = new Date().toISOString();
+  saveKnowledgeRegistry(registry, cwd);
+}
+
+/**
+ * Format a knowledge item for archive
+ * @param {Object} item - Knowledge item
+ * @returns {string}
+ */
+function formatArchiveEntry(item) {
+  const divider = '\n---\n\n';
+  const header = `## ${item.id}: ${item.title} [ARCHIVED]\n`;
+  const metadata = [
+    `**Type:** ${item.type}`,
+    `**Created:** ${item.createdAt || 'Unknown'}`,
+    `**Archived:** ${new Date().toISOString().split('T')[0]}`,
+    `**Access Count:** ${item.accessCount || 0}`,
+    `**Applied Count:** ${item.appliedCount || 0}`,
+    `**Last Accessed:** ${item.lastAccessed || 'Never'}`
+  ].join('\n');
+
+  const refs = [];
+  if (item.relatedFiles?.length) {
+    refs.push(`**Related Files:** ${item.relatedFiles.join(', ')}`);
+  }
+  if (item.relatedDecisions?.length) {
+    refs.push(`**Related Decisions:** ${item.relatedDecisions.join(', ')}`);
+  }
+  if (item.appliedContexts?.length) {
+    refs.push(`**Applied Contexts:** ${item.appliedContexts.join(', ')}`);
+  }
+
+  return header + metadata + '\n' + refs.join('\n') + divider;
+}
+
+/**
+ * Get items that are candidates for archival (inactive but not orphaned)
+ * @param {number} inactiveDays - Days of inactivity
+ * @param {string} cwd - Working directory
+ * @returns {Object[]}
+ */
+export function getArchivalCandidates(inactiveDays = 60, cwd = process.cwd()) {
+  const registry = getKnowledgeRegistry(cwd);
+  if (!registry) return [];
+
+  const candidates = [];
+  const cutoff = new Date(Date.now() - inactiveDays * 24 * 60 * 60 * 1000);
+
+  for (const [id, item] of Object.entries(registry.items)) {
+    if (item.status !== 'active') continue;
+
+    const lastAccessed = item.lastAccessed ? new Date(item.lastAccessed) : null;
+
+    // Has references but hasn't been accessed
+    const hasRefs = (item.relatedFiles || []).length > 0 ||
+                    (item.relatedDecisions || []).length > 0;
+
+    if (hasRefs && (!lastAccessed || lastAccessed < cutoff)) {
+      candidates.push({
+        id,
+        title: item.title,
+        lastAccessed: item.lastAccessed,
+        daysSinceAccess: lastAccessed
+          ? Math.floor((Date.now() - lastAccessed) / (24 * 60 * 60 * 1000))
+          : 'never',
+        refCount: (item.relatedFiles || []).length + (item.relatedDecisions || []).length
+      });
+    }
+  }
+
+  return candidates.sort((a, b) => {
+    const aDate = a.lastAccessed ? new Date(a.lastAccessed) : new Date(0);
+    const bDate = b.lastAccessed ? new Date(b.lastAccessed) : new Date(0);
+    return aDate - bDate;
+  });
+}
+
+/**
+ * Restore an archived item back to active
+ * @param {string} id - Item ID
+ * @param {string} cwd - Working directory
+ * @returns {Object|null}
+ */
+export function restoreFromArchive(id, cwd = process.cwd()) {
+  const registry = getKnowledgeRegistry(cwd);
+  if (!registry || !registry.items[id]) return null;
+
+  const item = registry.items[id];
+  if (item.status !== 'archived') {
+    return { error: `Item ${id} is not archived (status: ${item.status})` };
+  }
+
+  item.status = 'active';
+  item.restoredAt = new Date().toISOString();
+  delete item.archivedAt;
+
+  saveKnowledgeRegistry(registry, cwd);
+  return item;
+}
+
+/**
+ * Get GC statistics
+ * @param {string} cwd - Working directory
+ * @returns {Object}
+ */
+export function getGCStats(cwd = process.cwd()) {
+  const registry = getKnowledgeRegistry(cwd);
+  const garbage = identifyGarbage(cwd);
+  const archivalCandidates = getArchivalCandidates(60, cwd);
+  const broken = findBrokenReferences(cwd);
+
+  return {
+    lastGC: registry?.lastGC || 'Never',
+    garbageCount: garbage.length,
+    archivalCandidates: archivalCandidates.length,
+    brokenReferences: broken.length,
+    garbage: garbage.map(g => ({ id: g.id, reason: g.reason })),
+    candidates: archivalCandidates.slice(0, 5)
+  };
+}