@fermindi/pwn-cli 0.1.0

package/src/core/workspace.js

@@ -0,0 +1,176 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { getState } from './state.js';
+
+/**
+ * Get comprehensive workspace information
+ * @param {string} cwd - Working directory
+ * @returns {object} Workspace info
+ */
+export function getWorkspaceInfo(cwd = process.cwd()) {
+  const aiDir = join(cwd, '.ai');
+
+  if (!existsSync(aiDir)) {
+    return {
+      exists: false,
+      path: aiDir
+    };
+  }
+
+  const state = getState(cwd);
+  const tasks = getTasksSummary(cwd);
+  const memory = getMemorySummary(cwd);
+  const patterns = getPatternsSummary(cwd);
+
+  return {
+    exists: true,
+    path: aiDir,
+    state,
+    tasks,
+    memory,
+    patterns
+  };
+}
+
+/**
+ * Get summary of active tasks
+ * @param {string} cwd - Working directory
+ * @returns {object} Tasks summary
+ */
+function getTasksSummary(cwd) {
+  const activePath = join(cwd, '.ai', 'tasks', 'active.md');
+  const backlogPath = join(cwd, '.ai', 'tasks', 'backlog.md');
+
+  const summary = {
+    active: { total: 0, completed: 0, pending: 0 },
+    backlog: { total: 0 }
+  };
+
+  // Parse active.md
+  if (existsSync(activePath)) {
+    const content = readFileSync(activePath, 'utf8');
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+      if (line.match(/^- \[[ x]\]/)) {
+        summary.active.total++;
+        if (line.match(/^- \[x\]/i)) {
+          summary.active.completed++;
+        } else {
+          summary.active.pending++;
+        }
+      }
+    }
+  }
+
+  // Parse backlog.md
+  if (existsSync(backlogPath)) {
+    const content = readFileSync(backlogPath, 'utf8');
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+      if (line.match(/^- \[[ ]\]/) || line.match(/^\d+\./)) {
+        summary.backlog.total++;
+      }
+    }
+  }
+
+  return summary;
+}
+
+/**
+ * Get summary of memory files
+ * @param {string} cwd - Working directory
+ * @returns {object} Memory summary
+ */
+function getMemorySummary(cwd) {
+  const memoryDir = join(cwd, '.ai', 'memory');
+
+  const summary = {
+    decisions: 0,
+    patterns: 0,
+    deadends: 0
+  };
+
+  // Count decisions (DEC-XXX format)
+  const decisionsPath = join(memoryDir, 'decisions.md');
+  if (existsSync(decisionsPath)) {
+    const content = readFileSync(decisionsPath, 'utf8');
+    const matches = content.match(/DEC-\d+/g);
+    summary.decisions = matches ? matches.length : 0;
+  }
+
+  // Count patterns (### headers in patterns.md)
+  const patternsPath = join(memoryDir, 'patterns.md');
+  if (existsSync(patternsPath)) {
+    const content = readFileSync(patternsPath, 'utf8');
+    const matches = content.match(/^### /gm);
+    summary.patterns = matches ? matches.length : 0;
+  }
+
+  // Count dead-ends (DE-XXX format)
+  const deadendsPath = join(memoryDir, 'deadends.md');
+  if (existsSync(deadendsPath)) {
+    const content = readFileSync(deadendsPath, 'utf8');
+    const matches = content.match(/DE-\d+/g);
+    summary.deadends = matches ? matches.length : 0;
+  }
+
+  return summary;
+}
+
+/**
+ * Get summary of pattern triggers
+ * @param {string} cwd - Working directory
+ * @returns {object} Patterns summary
+ */
+function getPatternsSummary(cwd) {
+  const patternsDir = join(cwd, '.ai', 'patterns');
+
+  const summary = {
+    triggers: 0,
+    categories: []
+  };
+
+  // Count triggers in index.md
+  const indexPath = join(patternsDir, 'index.md');
+  if (existsSync(indexPath)) {
+    const content = readFileSync(indexPath, 'utf8');
+    // Count lines that look like trigger mappings (| pattern | directory |)
+    const matches = content.match(/^\|[^|]+\|[^|]+\|$/gm);
+    // Subtract header rows (usually 2)
+    summary.triggers = matches ? Math.max(0, matches.length - 2) : 0;
+  }
+
+  // List pattern categories (subdirectories)
+  if (existsSync(patternsDir)) {
+    const entries = readdirSync(patternsDir);
+    for (const entry of entries) {
+      const entryPath = join(patternsDir, entry);
+      if (statSync(entryPath).isDirectory()) {
+        summary.categories.push(entry);
+      }
+    }
+  }
+
+  return summary;
+}
+
+/**
+ * Check if current directory is inside a PWN workspace
+ * @param {string} cwd - Starting directory
+ * @returns {string|null} Path to .ai directory or null
+ */
+export function findWorkspaceRoot(cwd = process.cwd()) {
+  let current = cwd;
+
+  while (current !== join(current, '..')) {
+    const aiDir = join(current, '.ai');
+    if (existsSync(aiDir)) {
+      return current;
+    }
+    current = join(current, '..');
+  }
+
+  return null;
+}

package/src/index.js

@@ -0,0 +1,20 @@
+// PWN Core - Main exports
+export { inject } from './core/inject.js';
+export { getState, updateState, initState } from './core/state.js';
+export { validate } from './core/validate.js';
+export { getWorkspaceInfo } from './core/workspace.js';
+
+// Services
+export * as notifications from './services/notification-service.js';
+export * as batch from './services/batch-service.js';
+
+// Patterns
+export * as patterns from './patterns/registry.js';
+export * as triggers from './patterns/triggers.js';
+export * as matcher from './patterns/matcher.js';
+
+// Knowledge Lifecycle
+export * as lifecycle from './knowledge/lifecycle.js';
+export * as references from './knowledge/references.js';
+export * as gc from './knowledge/gc.js';
+export * as promote from './knowledge/promote.js';

package/src/knowledge/gc.js

@@ -0,0 +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)
+  };
+}