@fermindi/pwn-cli 0.1.1 → 0.2.0

package/src/knowledge/promote.js

@@ -1,364 +1,364 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } from 'fs';
-import { join } from 'path';
-import {
-  getKnowledgeRegistry,
-  saveKnowledgeRegistry,
-  getKnowledgeItem,
-  changeStatus,
-  getAllKnowledge
-} from './lifecycle.js';
-
-/**
- * Promotion criteria configuration
- */
-export const PROMOTION_CRITERIA = {
-  // Minimum times the decision was applied in code
-  minAppliedCount: 3,
-  // Minimum different contexts where it was applied
-  minAppliedContexts: 2,
-  // Minimum access count
-  minAccessCount: 5
-};
-
-/**
- * Check if a decision is eligible for promotion to pattern
- * @param {string} id - Decision ID
- * @param {string} cwd - Working directory
- * @returns {Object} Eligibility result
- */
-export function checkPromotionEligibility(id, cwd = process.cwd()) {
-  const item = getKnowledgeItem(id, cwd);
-
-  if (!item) {
-    return { eligible: false, reason: 'Item not found' };
-  }
-
-  if (item.type !== 'decision') {
-    return { eligible: false, reason: 'Only decisions can be promoted to patterns' };
-  }
-
-  if (item.status === 'archived' || item.status === 'garbage') {
-    return { eligible: false, reason: `Item is ${item.status}` };
-  }
-
-  const criteria = {
-    appliedCount: {
-      current: item.appliedCount || 0,
-      required: PROMOTION_CRITERIA.minAppliedCount,
-      met: (item.appliedCount || 0) >= PROMOTION_CRITERIA.minAppliedCount
-    },
-    appliedContexts: {
-      current: (item.appliedContexts || []).length,
-      required: PROMOTION_CRITERIA.minAppliedContexts,
-      met: (item.appliedContexts || []).length >= PROMOTION_CRITERIA.minAppliedContexts
-    },
-    accessCount: {
-      current: item.accessCount || 0,
-      required: PROMOTION_CRITERIA.minAccessCount,
-      met: (item.accessCount || 0) >= PROMOTION_CRITERIA.minAccessCount
-    }
-  };
-
-  const allMet = criteria.appliedCount.met &&
-                 criteria.appliedContexts.met &&
-                 criteria.accessCount.met;
-
-  return {
-    eligible: allMet,
-    criteria,
-    item: {
-      id: item.id,
-      title: item.title,
-      status: item.status,
-      appliedContexts: item.appliedContexts || []
-    }
-  };
-}
-
-/**
- * Get all decisions that are candidates for promotion
- * @param {string} cwd - Working directory
- * @returns {Object[]}
- */
-export function getPromotionCandidates(cwd = process.cwd()) {
-  const decisions = getAllKnowledge({ type: 'decision' }, cwd);
-  const candidates = [];
-
-  for (const decision of decisions) {
-    if (decision.status === 'archived' || decision.status === 'garbage') {
-      continue;
-    }
-
-    const eligibility = checkPromotionEligibility(decision.id, cwd);
-
-    if (eligibility.eligible || decision.status === 'candidate_pattern') {
-      candidates.push({
-        id: decision.id,
-        title: decision.title,
-        status: decision.status,
-        eligibility: eligibility.criteria,
-        isEligible: eligibility.eligible
-      });
-    }
-  }
-
-  // Sort by applied count descending
-  return candidates.sort((a, b) =>
-    (b.eligibility?.appliedCount?.current || 0) -
-    (a.eligibility?.appliedCount?.current || 0)
-  );
-}
-
-/**
- * Promote a decision to a pattern
- * Creates a new pattern file and updates the decision status
- * @param {string} id - Decision ID
- * @param {Object} options - Options
- * @param {string} options.category - Pattern category (frontend, backend, universal)
- * @param {string} options.name - Pattern name (for filename)
- * @param {string} cwd - Working directory
- * @returns {Object}
- */
-export function promoteToPattern(id, options = {}, cwd = process.cwd()) {
-  const eligibility = checkPromotionEligibility(id, cwd);
-
-  if (!eligibility.eligible && !options.force) {
-    return {
-      success: false,
-      error: 'Decision does not meet promotion criteria',
-      eligibility
-    };
-  }
-
-  const item = getKnowledgeItem(id, cwd);
-  if (!item) {
-    return { success: false, error: 'Item not found' };
-  }
-
-  // Determine category
-  const category = options.category || inferCategory(item);
-  const patternName = options.name || slugify(item.title);
-
-  // Create pattern file
-  const patternDir = join(cwd, '.ai', 'patterns', category);
-  if (!existsSync(patternDir)) {
-    mkdirSync(patternDir, { recursive: true });
-  }
-
-  const patternFile = join(patternDir, `${patternName}.md`);
-  const patternContent = generatePatternContent(item);
-
-  writeFileSync(patternFile, patternContent);
-
-  // Update decision status
-  const registry = getKnowledgeRegistry(cwd);
-  registry.items[id].status = 'promoted';
-  registry.items[id].promotedTo = `patterns/${category}/${patternName}.md`;
-  registry.items[id].promotedAt = new Date().toISOString();
-  saveKnowledgeRegistry(registry, cwd);
-
-  // Add to patterns index
-  updatePatternsIndex(item, category, patternName, cwd);
-
-  return {
-    success: true,
-    patternFile: `patterns/${category}/${patternName}.md`,
-    decision: id,
-    category
-  };
-}
-
-/**
- * Infer the category for a pattern based on its contexts
- * @param {Object} item - Knowledge item
- * @returns {string}
- */
-function inferCategory(item) {
-  const contexts = item.appliedContexts || [];
-  const contextStr = contexts.join(' ').toLowerCase();
-
-  // Check for frontend patterns
-  const frontendKeywords = ['component', 'react', 'vue', 'svelte', 'ui', 'css', 'style', 'hook'];
-  if (frontendKeywords.some(kw => contextStr.includes(kw))) {
-    return 'frontend';
-  }
-
-  // Check for backend patterns
-  const backendKeywords = ['api', 'server', 'database', 'auth', 'middleware', 'route', 'controller'];
-  if (backendKeywords.some(kw => contextStr.includes(kw))) {
-    return 'backend';
-  }
-
-  return 'universal';
-}
-
-/**
- * Generate pattern content from a decision
- * @param {Object} item - Knowledge item
- * @returns {string}
- */
-function generatePatternContent(item) {
-  const content = `# ${item.title}
-
-> Promoted from ${item.id} on ${new Date().toISOString().split('T')[0]}
-
-## Context
-
-This pattern was identified after being applied ${item.appliedCount || 0} times across ${(item.appliedContexts || []).length} different contexts.
-
-## Pattern
-
-<!-- Describe the pattern here -->
-
-## When to Use
-
-Applied contexts:
-${(item.appliedContexts || []).map(ctx => `- ${ctx}`).join('\n')}
-
-## Example
-
-\`\`\`
-// Add example code here
-\`\`\`
-
-## Related
-
-- Source: ${item.id}
-${(item.relatedDecisions || []).map(d => `- ${d}`).join('\n')}
-
-## Statistics
-
-- Applied: ${item.appliedCount || 0} times
-- Accessed: ${item.accessCount || 0} times
-- First created: ${item.createdAt || 'Unknown'}
-`;
-
-  return content;
-}
-
-/**
- * Convert a string to a slug
- * @param {string} str - Input string
- * @returns {string}
- */
-function slugify(str) {
-  return str
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-|-$/g, '')
-    .substring(0, 50);
-}
-
-/**
- * Update patterns/index.md with new pattern
- * @param {Object} item - Knowledge item
- * @param {string} category - Pattern category
- * @param {string} patternName - Pattern filename (without .md)
- * @param {string} cwd - Working directory
- */
-function updatePatternsIndex(item, category, patternName, cwd = process.cwd()) {
-  const indexPath = join(cwd, '.ai', 'patterns', 'index.md');
-
-  if (!existsSync(indexPath)) {
-    return;
-  }
-
-  const entry = `\n## ${category}/${patternName}\n` +
-    `- **Promoted from:** ${item.id}\n` +
-    `- **Applied:** ${item.appliedCount || 0} times\n` +
-    `- **Description:** ${item.title}\n`;
-
-  appendFileSync(indexPath, entry);
-}
-
-/**
- * Get promotion statistics
- * @param {string} cwd - Working directory
- * @returns {Object}
- */
-export function getPromotionStats(cwd = process.cwd()) {
-  const registry = getKnowledgeRegistry(cwd);
-  if (!registry) {
-    return {
-      totalDecisions: 0,
-      promotedCount: 0,
-      candidateCount: 0,
-      eligibleCount: 0,
-      candidates: []
-    };
-  }
-
-  const items = Object.values(registry.items);
-  const decisions = items.filter(i => i.type === 'decision');
-
-  const promoted = decisions.filter(d => d.status === 'promoted');
-  const candidates = decisions.filter(d => d.status === 'candidate_pattern');
-
-  // Check eligibility for active decisions
-  let eligibleCount = 0;
-  for (const d of decisions) {
-    if (d.status === 'active') {
-      const elig = checkPromotionEligibility(d.id, cwd);
-      if (elig.eligible) eligibleCount++;
-    }
-  }
-
-  return {
-    totalDecisions: decisions.length,
-    promotedCount: promoted.length,
-    candidateCount: candidates.length,
-    eligibleCount,
-    promoted: promoted.map(p => ({
-      id: p.id,
-      title: p.title,
-      promotedTo: p.promotedTo,
-      promotedAt: p.promotedAt
-    })),
-    candidates: getPromotionCandidates(cwd).slice(0, 5)
-  };
-}
-
-/**
- * Suggest next best candidate for promotion
- * @param {string} cwd - Working directory
- * @returns {Object|null}
- */
-export function suggestPromotion(cwd = process.cwd()) {
-  const candidates = getPromotionCandidates(cwd);
-
-  // Find the first eligible candidate
-  const eligible = candidates.find(c => c.isEligible);
-  if (eligible) {
-    return {
-      type: 'ready',
-      ...eligible,
-      message: `${eligible.id} is ready for promotion to pattern`
-    };
-  }
-
-  // Find the closest to eligible
-  if (candidates.length > 0) {
-    const closest = candidates[0];
-    const criteria = closest.eligibility;
-
-    const missing = [];
-    if (!criteria.appliedCount.met) {
-      missing.push(`${criteria.appliedCount.required - criteria.appliedCount.current} more applications needed`);
-    }
-    if (!criteria.appliedContexts.met) {
-      missing.push(`${criteria.appliedContexts.required - criteria.appliedContexts.current} more contexts needed`);
-    }
-    if (!criteria.accessCount.met) {
-      missing.push(`${criteria.accessCount.required - criteria.accessCount.current} more accesses needed`);
-    }
-
-    return {
-      type: 'close',
-      ...closest,
-      missing,
-      message: `${closest.id} is close to promotion: ${missing.join(', ')}`
-    };
-  }
-
-  return null;
-}
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join } from 'path';
+import {
+  getKnowledgeRegistry,
+  saveKnowledgeRegistry,
+  getKnowledgeItem,
+  changeStatus,
+  getAllKnowledge
+} from './lifecycle.js';
+
+/**
+ * Promotion criteria configuration
+ */
+export const PROMOTION_CRITERIA = {
+  // Minimum times the decision was applied in code
+  minAppliedCount: 3,
+  // Minimum different contexts where it was applied
+  minAppliedContexts: 2,
+  // Minimum access count
+  minAccessCount: 5
+};
+
+/**
+ * Check if a decision is eligible for promotion to pattern
+ * @param {string} id - Decision ID
+ * @param {string} cwd - Working directory
+ * @returns {Object} Eligibility result
+ */
+export function checkPromotionEligibility(id, cwd = process.cwd()) {
+  const item = getKnowledgeItem(id, cwd);
+
+  if (!item) {
+    return { eligible: false, reason: 'Item not found' };
+  }
+
+  if (item.type !== 'decision') {
+    return { eligible: false, reason: 'Only decisions can be promoted to patterns' };
+  }
+
+  if (item.status === 'archived' || item.status === 'garbage') {
+    return { eligible: false, reason: `Item is ${item.status}` };
+  }
+
+  const criteria = {
+    appliedCount: {
+      current: item.appliedCount || 0,
+      required: PROMOTION_CRITERIA.minAppliedCount,
+      met: (item.appliedCount || 0) >= PROMOTION_CRITERIA.minAppliedCount
+    },
+    appliedContexts: {
+      current: (item.appliedContexts || []).length,
+      required: PROMOTION_CRITERIA.minAppliedContexts,
+      met: (item.appliedContexts || []).length >= PROMOTION_CRITERIA.minAppliedContexts
+    },
+    accessCount: {
+      current: item.accessCount || 0,
+      required: PROMOTION_CRITERIA.minAccessCount,
+      met: (item.accessCount || 0) >= PROMOTION_CRITERIA.minAccessCount
+    }
+  };
+
+  const allMet = criteria.appliedCount.met &&
+                 criteria.appliedContexts.met &&
+                 criteria.accessCount.met;
+
+  return {
+    eligible: allMet,
+    criteria,
+    item: {
+      id: item.id,
+      title: item.title,
+      status: item.status,
+      appliedContexts: item.appliedContexts || []
+    }
+  };
+}
+
+/**
+ * Get all decisions that are candidates for promotion
+ * @param {string} cwd - Working directory
+ * @returns {Object[]}
+ */
+export function getPromotionCandidates(cwd = process.cwd()) {
+  const decisions = getAllKnowledge({ type: 'decision' }, cwd);
+  const candidates = [];
+
+  for (const decision of decisions) {
+    if (decision.status === 'archived' || decision.status === 'garbage') {
+      continue;
+    }
+
+    const eligibility = checkPromotionEligibility(decision.id, cwd);
+
+    if (eligibility.eligible || decision.status === 'candidate_pattern') {
+      candidates.push({
+        id: decision.id,
+        title: decision.title,
+        status: decision.status,
+        eligibility: eligibility.criteria,
+        isEligible: eligibility.eligible
+      });
+    }
+  }
+
+  // Sort by applied count descending
+  return candidates.sort((a, b) =>
+    (b.eligibility?.appliedCount?.current || 0) -
+    (a.eligibility?.appliedCount?.current || 0)
+  );
+}
+
+/**
+ * Promote a decision to a pattern
+ * Creates a new pattern file and updates the decision status
+ * @param {string} id - Decision ID
+ * @param {Object} options - Options
+ * @param {string} options.category - Pattern category (frontend, backend, universal)
+ * @param {string} options.name - Pattern name (for filename)
+ * @param {string} cwd - Working directory
+ * @returns {Object}
+ */
+export function promoteToPattern(id, options = {}, cwd = process.cwd()) {
+  const eligibility = checkPromotionEligibility(id, cwd);
+
+  if (!eligibility.eligible && !options.force) {
+    return {
+      success: false,
+      error: 'Decision does not meet promotion criteria',
+      eligibility
+    };
+  }
+
+  const item = getKnowledgeItem(id, cwd);
+  if (!item) {
+    return { success: false, error: 'Item not found' };
+  }
+
+  // Determine category
+  const category = options.category || inferCategory(item);
+  const patternName = options.name || slugify(item.title);
+
+  // Create pattern file
+  const patternDir = join(cwd, '.ai', 'patterns', category);
+  if (!existsSync(patternDir)) {
+    mkdirSync(patternDir, { recursive: true });
+  }
+
+  const patternFile = join(patternDir, `${patternName}.md`);
+  const patternContent = generatePatternContent(item);
+
+  writeFileSync(patternFile, patternContent);
+
+  // Update decision status
+  const registry = getKnowledgeRegistry(cwd);
+  registry.items[id].status = 'promoted';
+  registry.items[id].promotedTo = `patterns/${category}/${patternName}.md`;
+  registry.items[id].promotedAt = new Date().toISOString();
+  saveKnowledgeRegistry(registry, cwd);
+
+  // Add to patterns index
+  updatePatternsIndex(item, category, patternName, cwd);
+
+  return {
+    success: true,
+    patternFile: `patterns/${category}/${patternName}.md`,
+    decision: id,
+    category
+  };
+}
+
+/**
+ * Infer the category for a pattern based on its contexts
+ * @param {Object} item - Knowledge item
+ * @returns {string}
+ */
+function inferCategory(item) {
+  const contexts = item.appliedContexts || [];
+  const contextStr = contexts.join(' ').toLowerCase();
+
+  // Check for frontend patterns
+  const frontendKeywords = ['component', 'react', 'vue', 'svelte', 'ui', 'css', 'style', 'hook'];
+  if (frontendKeywords.some(kw => contextStr.includes(kw))) {
+    return 'frontend';
+  }
+
+  // Check for backend patterns
+  const backendKeywords = ['api', 'server', 'database', 'auth', 'middleware', 'route', 'controller'];
+  if (backendKeywords.some(kw => contextStr.includes(kw))) {
+    return 'backend';
+  }
+
+  return 'universal';
+}
+
+/**
+ * Generate pattern content from a decision
+ * @param {Object} item - Knowledge item
+ * @returns {string}
+ */
+function generatePatternContent(item) {
+  const content = `# ${item.title}
+
+> Promoted from ${item.id} on ${new Date().toISOString().split('T')[0]}
+
+## Context
+
+This pattern was identified after being applied ${item.appliedCount || 0} times across ${(item.appliedContexts || []).length} different contexts.
+
+## Pattern
+
+<!-- Describe the pattern here -->
+
+## When to Use
+
+Applied contexts:
+${(item.appliedContexts || []).map(ctx => `- ${ctx}`).join('\n')}
+
+## Example
+
+\`\`\`
+// Add example code here
+\`\`\`
+
+## Related
+
+- Source: ${item.id}
+${(item.relatedDecisions || []).map(d => `- ${d}`).join('\n')}
+
+## Statistics
+
+- Applied: ${item.appliedCount || 0} times
+- Accessed: ${item.accessCount || 0} times
+- First created: ${item.createdAt || 'Unknown'}
+`;
+
+  return content;
+}
+
+/**
+ * Convert a string to a slug
+ * @param {string} str - Input string
+ * @returns {string}
+ */
+function slugify(str) {
+  return str
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .substring(0, 50);
+}
+
+/**
+ * Update patterns/index.md with new pattern
+ * @param {Object} item - Knowledge item
+ * @param {string} category - Pattern category
+ * @param {string} patternName - Pattern filename (without .md)
+ * @param {string} cwd - Working directory
+ */
+function updatePatternsIndex(item, category, patternName, cwd = process.cwd()) {
+  const indexPath = join(cwd, '.ai', 'patterns', 'index.md');
+
+  if (!existsSync(indexPath)) {
+    return;
+  }
+
+  const entry = `\n## ${category}/${patternName}\n` +
+    `- **Promoted from:** ${item.id}\n` +
+    `- **Applied:** ${item.appliedCount || 0} times\n` +
+    `- **Description:** ${item.title}\n`;
+
+  appendFileSync(indexPath, entry);
+}
+
+/**
+ * Get promotion statistics
+ * @param {string} cwd - Working directory
+ * @returns {Object}
+ */
+export function getPromotionStats(cwd = process.cwd()) {
+  const registry = getKnowledgeRegistry(cwd);
+  if (!registry) {
+    return {
+      totalDecisions: 0,
+      promotedCount: 0,
+      candidateCount: 0,
+      eligibleCount: 0,
+      candidates: []
+    };
+  }
+
+  const items = Object.values(registry.items);
+  const decisions = items.filter(i => i.type === 'decision');
+
+  const promoted = decisions.filter(d => d.status === 'promoted');
+  const candidates = decisions.filter(d => d.status === 'candidate_pattern');
+
+  // Check eligibility for active decisions
+  let eligibleCount = 0;
+  for (const d of decisions) {
+    if (d.status === 'active') {
+      const elig = checkPromotionEligibility(d.id, cwd);
+      if (elig.eligible) eligibleCount++;
+    }
+  }
+
+  return {
+    totalDecisions: decisions.length,
+    promotedCount: promoted.length,
+    candidateCount: candidates.length,
+    eligibleCount,
+    promoted: promoted.map(p => ({
+      id: p.id,
+      title: p.title,
+      promotedTo: p.promotedTo,
+      promotedAt: p.promotedAt
+    })),
+    candidates: getPromotionCandidates(cwd).slice(0, 5)
+  };
+}
+
+/**
+ * Suggest next best candidate for promotion
+ * @param {string} cwd - Working directory
+ * @returns {Object|null}
+ */
+export function suggestPromotion(cwd = process.cwd()) {
+  const candidates = getPromotionCandidates(cwd);
+
+  // Find the first eligible candidate
+  const eligible = candidates.find(c => c.isEligible);
+  if (eligible) {
+    return {
+      type: 'ready',
+      ...eligible,
+      message: `${eligible.id} is ready for promotion to pattern`
+    };
+  }
+
+  // Find the closest to eligible
+  if (candidates.length > 0) {
+    const closest = candidates[0];
+    const criteria = closest.eligibility;
+
+    const missing = [];
+    if (!criteria.appliedCount.met) {
+      missing.push(`${criteria.appliedCount.required - criteria.appliedCount.current} more applications needed`);
+    }
+    if (!criteria.appliedContexts.met) {
+      missing.push(`${criteria.appliedContexts.required - criteria.appliedContexts.current} more contexts needed`);
+    }
+    if (!criteria.accessCount.met) {
+      missing.push(`${criteria.accessCount.required - criteria.accessCount.current} more accesses needed`);
+    }
+
+    return {
+      type: 'close',
+      ...closest,
+      missing,
+      message: `${closest.id} is close to promotion: ${missing.join(', ')}`
+    };
+  }
+
+  return null;
+}