ocs-stats 1.1.1 → 1.1.4

package/README.md

@@ -177,11 +177,11 @@ The testing agent helps you write tests with an XP-based leveling system:
 | Level | Title | XP Required | Focus |
 |-------|-------|-------------|-------|
 | 1 | Novice | 0 | Basic unit tests |
-| 2 | Apprentice | 100 | Integration tests |
-| 3 | Practitioner | 300 | E2E tests |
-| 4 | Expert | 600 | Test patterns & mocking |
-| 5 | Master | 1,200 | Full coverage strategies |
-| 6 | Grandmaster | 2,500 | Testing excellence |
+| 2 | Apprentice | 150 | Integration tests |
+| 3 | Practitioner | 450 | E2E tests |
+| 4 | Expert | 900 | Test patterns & mocking |
+| 5 | Master | 1,500 | Full coverage strategies |
+| 6 | Grandmaster | 3,000 | Testing excellence |
 
 ### XP Awards
 

package/bin/cli.js

@@ -7,6 +7,8 @@ const args = process.argv.slice(2);
 const command = args[0];
 const isGlobal = args.includes('--global') || args.includes('-g');
 const isHelp = args.includes('--help') || args.includes('-h');
+const isForce = args.includes('--force') || args.includes('-f');
+const isCheck = args.includes('--check') || args.includes('-c');
 
 if (isHelp) {
   console.log(`
@@ -15,7 +17,9 @@ ocs-stats - Install OpenCode skills and agents
 Usage:
   npx ocs-stats              Install to current project
   npx ocs-stats --global     Install globally (~/.opencode)
-  npx ocs-stats update       Update skills (removes existing)
+  npx ocs-stats update       Update skills (smart merge)
+  npx ocs-stats update --check   Check for updates
+  npx ocs-stats update --force   Force fresh install
   npx ocs-stats stats        Show security agent progress
   npx ocs-stats stats testing   Show testing agent progress
   npx ocs-stats display-xp <amount> "<reason>"
@@ -23,11 +27,15 @@ Usage:
 
 Options:
   -g, --global    Install to user home directory
+  -f, --force     Force fresh install (delete + copy)
+  -c, --check     Check for updates without applying
   -h, --help      Show this help message
 
 Examples:
   npx ocs-stats
   npx ocs-stats update
+  npx ocs-stats update --check
+  npx ocs-stats update --force
   npx ocs-stats stats
   npx ocs-stats stats testing
   npx ocs-stats display-xp 35 "Fixed high issue"
@@ -36,21 +44,22 @@ Examples:
   process.exit(0);
 }
 
-if (command === 'update') {
-  update({ isGlobal }).catch((err) => {
-    console.error('Error:', err.message);
-    process.exit(1);
-  });
-  process.exit(0);
+else if (command === 'update') {
+  update({ isGlobal, force: isForce, checkOnly: isCheck })
+    .then(() => process.exit(0))
+    .catch((err) => {
+      console.error('Error:', err.message);
+      process.exit(1);
+    });
 }
 
-if (command === 'stats') {
+else if (command === 'stats') {
   const category = args[1] || 'security';
   stats(category);
   process.exit(0);
 }
 
-if (command === 'display-xp') {
+else if (command === 'display-xp') {
   const amount = args[1];
   const reason = args.slice(2).join(' ') || 'XP earned';
   const category = reason.includes('[testing]') ? 'testing' : 'security';
@@ -59,7 +68,9 @@ if (command === 'display-xp') {
   process.exit(0);
 }
 
-init({ isGlobal }).catch((err) => {
-  console.error('Error:', err.message);
-  process.exit(1);
-});
+else {
+  init({ isGlobal }).catch((err) => {
+    console.error('Error:', err.message);
+    process.exit(1);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocs-stats",
-  "version": "1.1.1",
+  "version": "1.1.4",
   "description": "OpenCode Skills - One-click installer with gamified XP stats",
   "type": "module",
   "bin": {

package/src/init.js

@@ -1,12 +1,32 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { performUpdate, checkForUpdates, formatUpdateSummary } from './merge.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
 
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    if (entry.name === '.git') continue;
+    
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 export async function init({ isGlobal = false } = {}) {
   const targetDir = isGlobal 
     ? path.join(process.env.HOME || process.env.USERPROFILE, '.opencode')
@@ -43,7 +63,7 @@ export async function init({ isGlobal = false } = {}) {
   }
 }
 
-export async function update({ isGlobal = false } = {}) {
+export async function update({ isGlobal = false, force = false, checkOnly = false } = {}) {
   const targetDir = isGlobal 
     ? path.join(process.env.HOME || process.env.USERPROFILE, '.opencode')
     : path.join(process.cwd(), '.opencode');
@@ -55,35 +75,32 @@ export async function update({ isGlobal = false } = {}) {
     process.exit(1);
   }
 
-  // Remove existing
-  fs.rmSync(targetDir, { recursive: true, force: true });
-  console.log('  Removed existing .opencode folder');
-
-  // Reinstall
-  copyDir(TEMPLATES_DIR, targetDir);
-  console.log('  Installed fresh copy\n');
+  if (force) {
+    console.log('  Force mode: Removing existing .opencode folder');
+    fs.rmSync(targetDir, { recursive: true, force: true });
+    copyDir(TEMPLATES_DIR, targetDir);
+    console.log('  Fresh install complete\n');
+    return;
+  }
 
-  console.log('Updated successfully!\n');
-  console.log('What was installed:');
-  console.log('  * Agents: security, testing');
-  console.log('  * Skills: commit, memories, mobile, security, testing, webapp');
-  console.log('  * Security: XP tracking, knowledge base');
-  console.log('  * Testing: XP tracking, knowledge base\n');
-}
+  if (checkOnly) {
+    console.log('  Checking for updates...\n');
+    const updateInfo = await checkForUpdates(targetDir);
+    if (!updateInfo.hasUpdates) {
+      console.log(`  Already up to date (v${updateInfo.currentVersion})\n`);
+      return;
+    }
+    formatUpdateSummary({ ...updateInfo, results: updateInfo.changes }, true);
+    return;
+  }
 
-function copyDir(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  
-  const entries = fs.readdirSync(src, { withFileTypes: true });
+  console.log('  Updating...\n');
+  const updateResult = await performUpdate(targetDir, { force, checkOnly });
   
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    
-    if (entry.isDirectory()) {
-      copyDir(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
+  if (!updateResult.updated) {
+    console.log(`  Already up to date (v${updateResult.currentVersion})\n`);
+    return;
   }
+  
+  formatUpdateSummary(updateResult, false);
 }

package/src/merge.js

@@ -0,0 +1,351 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
+
+export const FILE_STATE = {
+  NEW: 'new',
+  UNMODIFIED: 'unmodified',
+  MODIFIED: 'modified',
+  DELETED: 'deleted',
+};
+
+export const FILE_CATEGORY = {
+  XP_DATA: 'xp_data',
+  MEMORIES: 'memories',
+  KNOWLEDGE: 'knowledge',
+  SKILL: 'skill',
+  AGENT: 'agent',
+};
+
+const PROTECTED_CATEGORIES = [FILE_CATEGORY.XP_DATA, FILE_CATEGORY.MEMORIES];
+const MERGE_CATEGORIES = [FILE_CATEGORY.KNOWLEDGE];
+
+function hashFile(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, 'utf-8');
+  return crypto.createHash('md5').update(content).digest('hex');
+}
+
+function getCategory(relativePath) {
+  const pathLower = relativePath.toLowerCase();
+  
+  if (pathLower.includes('/xp.json') || pathLower.endsWith('xp.json')) {
+    return FILE_CATEGORY.XP_DATA;
+  }
+  if (pathLower.includes('/memories/') || pathLower.includes('memories/')) {
+    return FILE_CATEGORY.MEMORIES;
+  }
+  if (pathLower.includes('/knowledge.md')) {
+    return FILE_CATEGORY.KNOWLEDGE;
+  }
+  if (pathLower.includes('/skills/')) {
+    return FILE_CATEGORY.SKILL;
+  }
+  if (pathLower.includes('/agents/')) {
+    return FILE_CATEGORY.AGENT;
+  }
+  return FILE_CATEGORY.SKILL;
+}
+
+function compareVersion(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (parts1[i] > parts2[i]) return 1;
+    if (parts1[i] < parts2[i]) return -1;
+  }
+  return 0;
+}
+
+function getAllTemplateFiles(srcDir, baseDir = '') {
+  const files = [];
+  if (!fs.existsSync(srcDir)) return files;
+  
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === '.git') continue;
+    
+    const relativePath = path.join(baseDir, entry.name);
+    const srcPath = path.join(srcDir, entry.name);
+    
+    if (entry.isDirectory()) {
+      files.push(...getAllTemplateFiles(srcPath, relativePath));
+    } else {
+      files.push(relativePath);
+    }
+  }
+  return files;
+}
+
+function findNewSections(oldContent, newContent) {
+  const newLines = newContent.split('\n');
+  const oldLines = oldContent.split('\n');
+  const newSections = [];
+  
+  let inNewSection = false;
+  let newSectionStart = -1;
+  
+  for (let i = 0; i < newLines.length; i++) {
+    const line = newLines[i];
+    const isHeader = /^#{1,3}\s+/.test(line);
+    
+    if (isHeader && !oldContent.includes(line)) {
+      if (inNewSection && newSectionStart > -1) {
+        newSections.push(newLines.slice(newSectionStart, i).join('\n'));
+      }
+      newSectionStart = i;
+      inNewSection = true;
+    }
+  }
+  
+  if (inNewSection && newSectionStart > -1) {
+    newSections.push(newLines.slice(newSectionStart).join('\n'));
+  }
+  
+  return newSections;
+}
+
+function mergeKnowledgeFiles(userContent, templateContent) {
+  const newSections = findNewSections(userContent, templateContent);
+  
+  if (newSections.length === 0) {
+    return { action: 'unchanged', content: userContent };
+  }
+  
+  let merged = userContent;
+  
+  for (const section of newSections) {
+    merged += '\n\n---\n\n' + section;
+  }
+  
+  return { action: 'merged', content: merged };
+}
+
+export async function checkForUpdates(targetDir) {
+  const versionFile = path.join(targetDir, '.ocs-version');
+  const currentVersion = fs.existsSync(versionFile) 
+    ? fs.readFileSync(versionFile, 'utf-8').trim()
+    : '0.0.0';
+  
+  const templateVersion = fs.readFileSync(path.join(TEMPLATES_DIR, '.ocs-version'), 'utf-8').trim();
+  
+  const comparison = compareVersion(templateVersion, currentVersion);
+  
+  if (comparison <= 0) {
+    return {
+      hasUpdates: false,
+      currentVersion,
+      templateVersion,
+      changes: []
+    };
+  }
+  
+  const templateFiles = getAllTemplateFiles(TEMPLATES_DIR);
+  const changes = [];
+  
+  for (const relativePath of templateFiles) {
+    const templatePath = path.join(TEMPLATES_DIR, relativePath);
+    const targetPath = path.join(targetDir, relativePath);
+    
+    const templateHash = hashFile(templatePath);
+    const targetHash = hashFile(targetPath);
+    const category = getCategory(relativePath);
+    
+    let state;
+    if (!targetHash) {
+      state = FILE_STATE.NEW;
+    } else if (templateHash === targetHash) {
+      state = FILE_STATE.UNMODIFIED;
+    } else {
+      state = FILE_STATE.MODIFIED;
+    }
+    
+    changes.push({
+      relativePath,
+      category,
+      state,
+      templateHash,
+      targetHash
+    });
+  }
+  
+  return {
+    hasUpdates: comparison > 0,
+    currentVersion,
+    templateVersion,
+    changes
+  };
+}
+
+export async function performUpdate(targetDir, options = {}) {
+  const { force = false, checkOnly = false } = options;
+  
+  const versionFile = path.join(targetDir, '.ocs-version');
+  const currentVersion = fs.existsSync(versionFile) 
+    ? fs.readFileSync(versionFile, 'utf-8').trim()
+    : '0.0.0';
+  
+  const templateVersion = fs.readFileSync(path.join(TEMPLATES_DIR, '.ocs-version'), 'utf-8').trim();
+  
+  if (compareVersion(templateVersion, currentVersion) <= 0 && !force) {
+    console.log(`  Already up to date (v${currentVersion})\n`);
+    return { updated: false, changes: [] };
+  }
+  
+  const templateFiles = getAllTemplateFiles(TEMPLATES_DIR);
+  
+  const results = {
+    updated: [],
+    added: [],
+    conflicts: [],
+    skipped: [],
+    merged: []
+  };
+  
+  for (const relativePath of templateFiles) {
+    const templatePath = path.join(TEMPLATES_DIR, relativePath);
+    const targetPath = path.join(targetDir, relativePath);
+    const category = getCategory(relativePath);
+    
+    const isVersionFile = relativePath === '.ocs-version';
+    const templateHash = hashFile(templatePath);
+    const targetHash = hashFile(targetPath);
+    
+    if (!targetHash) {
+      if (!checkOnly) {
+        const destDir = path.dirname(targetPath);
+        if (!fs.existsSync(destDir)) {
+          fs.mkdirSync(destDir, { recursive: true });
+        }
+        fs.copyFileSync(templatePath, targetPath);
+      }
+      results.added.push(relativePath);
+      continue;
+    }
+    
+    if (isVersionFile) {
+      if (!checkOnly) {
+        fs.copyFileSync(templatePath, targetPath);
+      }
+      results.updated.push(relativePath);
+      continue;
+    }
+    
+    if (PROTECTED_CATEGORIES.includes(category)) {
+      results.skipped.push({ path: relativePath, reason: 'protected (user data)' });
+      continue;
+    }
+    
+    if (templateHash === targetHash) {
+      if (!checkOnly) {
+        fs.copyFileSync(templatePath, targetPath);
+      }
+      results.updated.push(relativePath);
+      continue;
+    }
+    
+    if (MERGE_CATEGORIES.includes(category)) {
+      const userContent = fs.readFileSync(targetPath, 'utf-8');
+      const templateContent = fs.readFileSync(templatePath, 'utf-8');
+      
+      const mergeResult = mergeKnowledgeFiles(userContent, templateContent);
+      
+      if (mergeResult.action === 'merged' && !checkOnly) {
+        fs.writeFileSync(targetPath, mergeResult.content, 'utf-8');
+      }
+      
+      results.merged.push({ path: relativePath, sectionsAdded: mergeResult.action === 'merged' ? 1 : 0 });
+      continue;
+    }
+    
+    if (checkOnly) {
+      results.conflicts.push({ path: relativePath, category });
+      continue;
+    }
+    
+    results.conflicts.push({ path: relativePath, category, needsPrompt: true });
+  }
+  
+  if (!checkOnly) {
+    fs.writeFileSync(versionFile, templateVersion, 'utf-8');
+  }
+  
+  return {
+    updated: true,
+    currentVersion,
+    templateVersion,
+    results
+  };
+}
+
+export function formatUpdateSummary(updateResult, checkOnly = false) {
+  const { results, templateVersion } = updateResult;
+  
+  console.log('');
+  
+  if (checkOnly) {
+    console.log(`  Template version: v${templateVersion}`);
+    console.log(`  Status: ${updateResult.hasUpdates ? 'Update available' : 'Up to date'}`);
+  } else {
+    console.log(`  Updated to v${templateVersion}`);
+  }
+  
+  if (results.added.length > 0) {
+    console.log(`\n  Added (${results.added.length}):`);
+    for (const file of results.added.slice(0, 5)) {
+      console.log(`    + ${file}`);
+    }
+    if (results.added.length > 5) {
+      console.log(`    ... and ${results.added.length - 5} more`);
+    }
+  }
+  
+  if (results.updated.length > 0) {
+    console.log(`\n  Updated (${results.updated.length}):`);
+    for (const file of results.updated.slice(0, 5)) {
+      console.log(`    ~ ${file}`);
+    }
+    if (results.updated.length > 5) {
+      console.log(`    ... and ${results.updated.length - 5} more`);
+    }
+  }
+  
+  if (results.merged.length > 0) {
+    console.log(`\n  Merged (${results.merged.length}):`);
+    for (const file of results.merged.slice(0, 3)) {
+      console.log(`    ◊ ${file.path}`);
+    }
+    if (results.merged.length > 3) {
+      console.log(`    ... and ${results.merged.length - 3} more`);
+    }
+  }
+  
+  if (results.skipped.length > 0) {
+    console.log(`\n  Skipped - protected (${results.skipped.length}):`);
+    for (const file of results.skipped.slice(0, 3)) {
+      console.log(`    ⊘ ${file.path} (${file.reason})`);
+    }
+    if (results.skipped.length > 3) {
+      console.log(`    ... and ${results.skipped.length - 3} more`);
+    }
+  }
+  
+  if (results.conflicts.length > 0) {
+    console.log(`\n  Conflicts (${results.conflicts.length}):`);
+    for (const file of results.conflicts.slice(0, 5)) {
+      console.log(`    ⚠ ${file.path}`);
+    }
+    if (results.conflicts.length > 5) {
+      console.log(`    ... and ${results.conflicts.length - 5} more`);
+    }
+    console.log(`\n  Run without --check to resolve conflicts`);
+  }
+  
+  console.log('');
+}

package/templates/.ocs-version

@@ -0,0 +1 @@
+1.1.4

package/templates/agents/testing.md

@@ -55,11 +55,11 @@ All mistakes are recorded in:
 | Level | Title | XP Required | Focus |
 |-------|-------|-------------|-------|
 | 1 | Novice | 0 | Basic unit tests |
-| 2 | Apprentice | 100 | Integration tests |
-| 3 | Practitioner | 300 | E2E tests |
-| 4 | Expert | 600 | Test patterns & mocking |
-| 5 | Master | 1200 | Full coverage strategies |
-| 6 | Grandmaster | 2500 | Testing excellence |
+| 2 | Apprentice | 150 | Integration tests |
+| 3 | Practitioner | 450 | E2E tests |
+| 4 | Expert | 900 | Test patterns & mocking |
+| 5 | Master | 1500 | Full coverage strategies |
+| 6 | Grandmaster | 3000 | Testing excellence |
 
 ## Level-Specific Focus
 
@@ -69,31 +69,31 @@ Focus on:
 - Simple function testing
 - Common matchers
 
-### Level 2 - Apprentice (100 XP)
+### Level 2 - Apprentice (150 XP)
 Adds:
 - Integration tests
 - API testing with mocked context
 - Database testing patterns
 
-### Level 3 - Practitioner (300 XP)
+### Level 3 - Practitioner (450 XP)
 Adds:
 - E2E testing with Playwright
 - Browser automation
 - User flow testing
 
-### Level 4 - Expert (600 XP)
+### Level 4 - Expert (900 XP)
 Adds:
 - Advanced mocking patterns
 - Test utilities and factories
 - Test organization
 
-### Level 5 - Master (1200 XP)
+### Level 5 - Master (1500 XP)
 Adds:
 - Coverage strategies
 - Flaky test prevention
 - Performance testing
 
-### Level 6 - Grandmaster (2500 XP)
+### Level 6 - Grandmaster (3000 XP)
 Adds:
 - Testing architecture
 - CI/CD integration
@@ -249,6 +249,16 @@ Display XP gain:
 npx ocs-stats display-xp 80 "Wrote 8 unit tests [testing]"
 ```
 
+This will display:
+```
+╔══════════════════════════════════════╗
+║  +80 XP  Wrote 8 unit tests         ║
+╠══════════════════════════════════════╣
+║  Level 1 - Novice                   ║
+║  [████████████░░░░░░░] 80/100       ║
+╚══════════════════════════════════════╝
+```
+
 ## Mistake Recording
 
 If you introduce a flaky test or make a mistake:

package/templates/testing/xp.json

@@ -51,10 +51,10 @@
   },
   "levelThresholds": [
     { "level": 1, "title": "Novice", "xpRequired": 0, "focus": "Basic unit tests" },
-    { "level": 2, "title": "Apprentice", "xpRequired": 100, "focus": "Integration tests" },
-    { "level": 3, "title": "Practitioner", "xpRequired": 300, "focus": "E2E tests" },
-    { "level": 4, "title": "Expert", "xpRequired": 600, "focus": "Test patterns & mocking" },
-    { "level": 5, "title": "Master", "xpRequired": 1200, "focus": "Full coverage strategies" },
-    { "level": 6, "title": "Grandmaster", "xpRequired": 2500, "focus": "Testing excellence" }
+    { "level": 2, "title": "Apprentice", "xpRequired": 150, "focus": "Integration tests" },
+    { "level": 3, "title": "Practitioner", "xpRequired": 450, "focus": "E2E tests" },
+    { "level": 4, "title": "Expert", "xpRequired": 900, "focus": "Test patterns & mocking" },
+    { "level": 5, "title": "Master", "xpRequired": 1500, "focus": "Full coverage strategies" },
+    { "level": 6, "title": "Grandmaster", "xpRequired": 3000, "focus": "Testing excellence" }
   ]
 }