codymaster 4.4.5 → 4.5.2

package/dist/token-budget.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultBudget = getDefaultBudget;
+exports.loadBudget = loadBudget;
+exports.checkBudget = checkBudget;
+exports.estimateTokens = estimateTokens;
+exports.generateBudgetReport = generateBudgetReport;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// ─── Constants ──────────────────────────────────────────────────────────────
+const CM_DIR = '.cm';
+const BUDGET_FILE = 'token-budget.json';
+// ─── Default Budget ─────────────────────────────────────────────────────────
+function getDefaultBudget() {
+    return {
+        model_context_window: 200000,
+        allocations: {
+            system_prompt: 5000, // 2.5%
+            skill_index_L0: 2500, // 1.25%
+            skill_active_full: 5000, // 2.5%
+            memory_working: 500, // 0.25%
+            memory_learnings: 650, // 0.325%
+            codebase_skeleton: 1500, // 0.75%
+            context_retrieval: 10000, // 5%
+            conversation_history: 30000, // 15%
+            generation_budget: 144850, // 72.425%
+        },
+        enforcement: 'soft',
+    };
+}
+// ─── Load Budget ────────────────────────────────────────────────────────────
+function loadBudget(projectPath) {
+    const budgetPath = path_1.default.join(projectPath, CM_DIR, BUDGET_FILE);
+    if (!fs_1.default.existsSync(budgetPath)) {
+        return getDefaultBudget();
+    }
+    try {
+        const raw = fs_1.default.readFileSync(budgetPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (_a) {
+        return getDefaultBudget();
+    }
+}
+// ─── Check Budget ────────────────────────────────────────────────────────────
+function checkBudget(budget, category, tokenCount) {
+    const allocs = budget.allocations;
+    const allocated = allocs[category];
+    if (allocated === undefined) {
+        return {
+            allowed: false,
+            remaining: 0,
+            suggestion: `Unknown category "${category}". Valid: ${Object.keys(allocs).join(', ')}`,
+        };
+    }
+    const remaining = allocated - tokenCount;
+    const overBudget = remaining < 0;
+    if (!overBudget) {
+        return { allowed: true, remaining };
+    }
+    const suggestion = buildSuggestion(category, tokenCount, allocated);
+    if (budget.enforcement === 'hard') {
+        return { allowed: false, remaining, suggestion };
+    }
+    // Soft mode: allow but warn
+    return { allowed: true, remaining, suggestion };
+}
+function buildSuggestion(category, used, allocated) {
+    const over = used - allocated;
+    if (category === 'memory_learnings') {
+        return `memory_learnings over by ~${over} tokens. Switch to L0 index (cm://memory/learnings/L0) to reduce to ~100 tokens.`;
+    }
+    if (category === 'codebase_skeleton') {
+        return `codebase_skeleton over by ~${over} tokens. Use cm://resources/skeleton/L0 for module-level index (~500 tokens).`;
+    }
+    if (category === 'memory_working') {
+        return `memory_working over by ~${over} tokens. Read CONTINUITY abstract only (first 3 lines).`;
+    }
+    return `${category} over budget by ~${over} tokens. Consider using L0 index instead of full content.`;
+}
+// ─── Estimate Tokens ─────────────────────────────────────────────────────────
+function estimateTokens(text) {
+    if (!text)
+        return 0;
+    return Math.ceil(text.length / 4);
+}
+// ─── Budget Report ────────────────────────────────────────────────────────────
+function generateBudgetReport(budget) {
+    const total = budget.model_context_window;
+    const lines = [
+        `Token Budget Report (${total.toLocaleString()} context window, enforcement: ${budget.enforcement})`,
+        '─'.repeat(70),
+        `${'Category'.padEnd(25)} ${'Allocated'.padStart(10)} ${'% of CTX'.padStart(10)}`,
+        '─'.repeat(70),
+    ];
+    const allocs = budget.allocations;
+    for (const [cat, allocated] of Object.entries(allocs)) {
+        const pct = ((allocated / total) * 100).toFixed(2);
+        lines.push(`${cat.padEnd(25)} ${allocated.toLocaleString().padStart(10)} ${(pct + '%').padStart(10)}`);
+    }
+    const sum = Object.values(allocs).reduce((a, b) => a + b, 0);
+    lines.push('─'.repeat(70));
+    lines.push(`${'TOTAL'.padEnd(25)} ${sum.toLocaleString().padStart(10)} ${(((sum / total) * 100).toFixed(2) + '%').padStart(10)}`);
+    return lines.join('\n');
+}

package/dist/uri-resolver.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = resolve;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const context_db_1 = require("./context-db");
+const context_bus_1 = require("./context-bus");
+// ─── Main Resolver ───────────────────────────────────────────────────────────
+/**
+ * Resolve a cm:// URI to content at the requested depth.
+ *
+ * URI patterns:
+ *   cm://memory/working             → CONTINUITY.md abstract (L0) or full (L2)
+ *   cm://memory/learnings           → learnings index (L0) or all learnings (L2)
+ *   cm://memory/learnings/{id}      → specific learning by ID
+ *   cm://memory/decisions           → decisions index (L0) or all (L2)
+ *   cm://skills/{name}              → SKILL.md at depth
+ *   cm://skills/{name}/L0           → index entry only
+ *   cm://resources/skeleton         → skeleton-index.md (L0) or full (L2)
+ *   cm://resources/architecture     → architecture.mmd
+ *   cm://pipeline/current           → context bus state
+ */
+function resolve(uri, projectPath, depth = 'L1') {
+    if (!uri.startsWith('cm://')) {
+        return notFound(uri, depth, `URI must start with cm://`);
+    }
+    const rest = uri.slice('cm://'.length); // e.g. "memory/learnings/L005"
+    const parts = rest.split('/').filter(Boolean);
+    if (parts.length === 0) {
+        return notFound(uri, depth, 'Empty URI path');
+    }
+    const [ns, ...tail] = parts;
+    switch (ns) {
+        case 'memory': return resolveMemory(uri, tail, projectPath, depth);
+        case 'skills': return resolveSkill(uri, tail, projectPath, depth);
+        case 'resources': return resolveResource(uri, tail, projectPath, depth);
+        case 'pipeline': return resolvePipeline(uri, tail, projectPath, depth);
+        default:
+            return notFound(uri, depth, `Unknown namespace "${ns}". Valid: memory, skills, resources, pipeline`);
+    }
+}
+// ─── memory/* ────────────────────────────────────────────────────────────────
+function resolveMemory(uri, tail, projectPath, depth) {
+    const [resource, id] = tail;
+    switch (resource) {
+        case 'working': {
+            const contPath = path_1.default.join(projectPath, '.cm', 'CONTINUITY.md');
+            if (!fs_1.default.existsSync(contPath))
+                return notFound(uri, depth, 'CONTINUITY.md not found');
+            const full = fs_1.default.readFileSync(contPath, 'utf-8');
+            if (depth === 'L0' || depth === 'L1') {
+                // Return first 10 non-empty lines as abstract
+                const abstract = full.split('\n').filter(l => l.trim()).slice(0, 10).join('\n');
+                return found(uri, depth, abstract);
+            }
+            return found(uri, depth, full);
+        }
+        case 'learnings': {
+            if (id) {
+                // cm://memory/learnings/L005 — specific entry
+                const dbPath = (0, context_db_1.getDbPath)(projectPath);
+                const learning = (0, context_db_1.getLearningById)(dbPath, id);
+                if (!learning)
+                    return notFound(uri, depth, `Learning "${id}" not found`);
+                return found(uri, depth, formatLearning(learning));
+            }
+            if (depth === 'L0') {
+                // Return cached L0 index
+                const indexPath = path_1.default.join(projectPath, '.cm', 'learnings-index.md');
+                if (fs_1.default.existsSync(indexPath)) {
+                    return found(uri, depth, fs_1.default.readFileSync(indexPath, 'utf-8'));
+                }
+            }
+            // L1/L2: query all from SQLite
+            const dbPath = (0, context_db_1.getDbPath)(projectPath);
+            const learnings = (0, context_db_1.queryLearnings)(dbPath, '', undefined, 50);
+            if (learnings.length === 0) {
+                // Fallback to JSON file
+                const jsonPath = path_1.default.join(projectPath, '.cm', 'memory', 'learnings.json');
+                if (fs_1.default.existsSync(jsonPath)) {
+                    return found(uri, depth, fs_1.default.readFileSync(jsonPath, 'utf-8'));
+                }
+                return found(uri, depth, '[]');
+            }
+            return found(uri, depth, JSON.stringify(learnings, null, 2));
+        }
+        case 'decisions': {
+            if (depth === 'L0') {
+                // Short list of decision IDs + 1-line summary
+                const dbPath = (0, context_db_1.getDbPath)(projectPath);
+                const decisions = (0, context_db_1.queryDecisions)(dbPath, '', 20);
+                const lines = ['# Decisions Index', ''];
+                for (const d of decisions) {
+                    lines.push(`- ${d.id}: ${d.decision.slice(0, 80)}`);
+                }
+                return found(uri, depth, lines.join('\n'));
+            }
+            const dbPath = (0, context_db_1.getDbPath)(projectPath);
+            const decisions = (0, context_db_1.queryDecisions)(dbPath, '', 50);
+            if (decisions.length === 0) {
+                const jsonPath = path_1.default.join(projectPath, '.cm', 'memory', 'decisions.json');
+                if (fs_1.default.existsSync(jsonPath)) {
+                    return found(uri, depth, fs_1.default.readFileSync(jsonPath, 'utf-8'));
+                }
+                return found(uri, depth, '[]');
+            }
+            return found(uri, depth, JSON.stringify(decisions, null, 2));
+        }
+        default:
+            return notFound(uri, depth, `Unknown memory resource "${resource}". Valid: working, learnings, decisions`);
+    }
+}
+// ─── skills/* ────────────────────────────────────────────────────────────────
+function resolveSkill(uri, tail, projectPath, depth) {
+    const [skillName, depthOverride] = tail;
+    if (!skillName)
+        return notFound(uri, depth, 'Skill name required: cm://skills/{name}');
+    const effectiveDepth = depthOverride || depth;
+    // Look in project skills/ dir, then global ~/.claude/skills/
+    const candidates = [
+        path_1.default.join(projectPath, 'skills', skillName, 'SKILL.md'),
+        path_1.default.join(projectPath, '.claude', 'skills', skillName, 'SKILL.md'),
+        path_1.default.join(process.env.HOME || '', '.claude', 'skills', skillName, 'SKILL.md'),
+    ];
+    const skillPath = candidates.find(p => fs_1.default.existsSync(p));
+    if (!skillPath)
+        return notFound(uri, depth, `Skill "${skillName}" not found`);
+    const full = fs_1.default.readFileSync(skillPath, 'utf-8');
+    if (effectiveDepth === 'L0') {
+        // Front matter + description only (~50 tokens)
+        const lines = full.split('\n');
+        const summary = lines.slice(0, 10).join('\n');
+        return found(uri, effectiveDepth, summary);
+    }
+    if (effectiveDepth === 'L1') {
+        // First 40 lines (~600 tokens)
+        return found(uri, effectiveDepth, full.split('\n').slice(0, 40).join('\n'));
+    }
+    return found(uri, effectiveDepth, full);
+}
+// ─── resources/* ─────────────────────────────────────────────────────────────
+function resolveResource(uri, tail, projectPath, depth) {
+    const [resource] = tail;
+    switch (resource) {
+        case 'skeleton': {
+            if (depth === 'L0' || depth === 'L1') {
+                const indexPath = path_1.default.join(projectPath, '.cm', 'skeleton-index.md');
+                if (fs_1.default.existsSync(indexPath)) {
+                    return found(uri, depth, fs_1.default.readFileSync(indexPath, 'utf-8'));
+                }
+            }
+            const fullPath = path_1.default.join(projectPath, '.cm', 'skeleton.md');
+            if (!fs_1.default.existsSync(fullPath))
+                return notFound(uri, depth, 'skeleton.md not found — run: cm continuity index');
+            return found(uri, depth, fs_1.default.readFileSync(fullPath, 'utf-8'));
+        }
+        case 'architecture': {
+            const mmdPath = path_1.default.join(projectPath, '.cm', 'architecture.mmd');
+            if (!fs_1.default.existsSync(mmdPath))
+                return notFound(uri, depth, 'architecture.mmd not found');
+            return found(uri, depth, fs_1.default.readFileSync(mmdPath, 'utf-8'));
+        }
+        default:
+            return notFound(uri, depth, `Unknown resource "${resource}". Valid: skeleton, architecture`);
+    }
+}
+// ─── pipeline/* ──────────────────────────────────────────────────────────────
+function resolvePipeline(uri, tail, projectPath, depth) {
+    const [sub] = tail;
+    if (!sub || sub === 'current') {
+        const bus = (0, context_bus_1.readBus)(projectPath);
+        if (!bus)
+            return notFound(uri, depth, 'No active context bus. Start a chain first.');
+        if (depth === 'L0') {
+            const summary = `Pipeline: ${bus.pipeline} | Step: ${bus.current_step} | Steps done: ${Object.keys(bus.shared_context).length}`;
+            return found(uri, depth, summary);
+        }
+        return found(uri, depth, JSON.stringify(bus, null, 2));
+    }
+    return notFound(uri, depth, `Unknown pipeline resource "${sub}"`);
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function found(uri, depth, content) {
+    return { uri, depth, content, tokenEstimate: Math.ceil(content.length / 4), found: true };
+}
+function notFound(uri, depth, reason) {
+    const content = `# Not Found\n\nURI: ${uri}\nReason: ${reason}`;
+    return { uri, depth, content, tokenEstimate: Math.ceil(content.length / 4), found: false };
+}
+function formatLearning(l) {
+    var _a, _b;
+    if (!l)
+        return '';
+    return [
+        `### ${l.id}: ${l.what_failed}`,
+        `- **Why:** ${l.why_failed}`,
+        `- **Fix:** ${l.how_to_prevent}`,
+        `- **Scope:** ${(_a = l.scope) !== null && _a !== void 0 ? _a : 'global'} | **TTL:** ${(_b = l.ttl) !== null && _b !== void 0 ? _b : 60}d`,
+    ].join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codymaster",
-  "version": "4.4.5",
+  "version": "4.5.2",
   "description": "68+ Skills. Ship 10x faster. AI-powered coding skill kit for Claude, Cursor, Gemini & more.",
   "main": "dist/index.js",
   "repository": {
@@ -46,6 +46,7 @@
   "type": "commonjs",
   "files": [
     "dist/",
+    "scripts/",
     "skills/",
     "adapters/",
     "commands/",
@@ -59,12 +60,15 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.1.0",
+    "better-sqlite3": "^12.8.0",
     "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
     "commander": "^14.0.3",
     "express": "^5.2.1",
     "prompts": "^2.4.2"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^5.0.6",
     "@types/node": "^25.5.0",
     "@types/prompts": "^2.4.9",

package/scripts/gate-0-secrets.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * Gate 0: Secret Hygiene
+ * Fastest gate (< 0.5s). Checks for leaked secrets before anything else runs.
+ */
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+let failed = false;
+
+// 1. Check wrangler config files for hardcoded secret values
+const wranglerFiles = ['wrangler.toml', 'wrangler.jsonc', 'wrangler.json'];
+const dangerous = [
+  'SERVICE_KEY', 'ANON_KEY', 'DB_PASSWORD', 'SECRET_KEY', 'PRIVATE_KEY', 'API_SECRET',
+  'GCP_SERVICE_ACCOUNT', 'AZURE_CONNECTION_STRING', 'HEROKU_API_KEY', 'POSTMAN_API_KEY'
+];
+
+for (const wf of wranglerFiles) {
+  if (!fs.existsSync(wf)) continue;
+  const src = fs.readFileSync(wf, 'utf-8');
+  for (const key of dangerous) {
+    const valuePattern = new RegExp(key + '\\s*[=:]\\s*["\'][a-zA-Z0-9/+=]{20,}', 'g');
+    if (valuePattern.test(src)) {
+      console.error('❌ DANGEROUS: ' + wf + ' contains a ' + key + ' VALUE');
+      console.error('   Fix: wrangler secret put ' + key + ' (then remove from ' + wf + ')');
+      failed = true;
+    }
+  }
+}
+
+// 2. Check .gitignore has required patterns
+if (fs.existsSync('.gitignore')) {
+  const gi = fs.readFileSync('.gitignore', 'utf-8');
+  const required = ['.env', '.dev.vars'];
+  const missing = required.filter(r => !gi.includes(r));
+  if (missing.length > 0) {
+    console.error('❌ .gitignore missing: ' + missing.join(', '));
+    failed = true;
+  }
+} else {
+  console.error('❌ No .gitignore found!');
+  failed = true;
+}
+
+// 3. Check .env / .dev.vars files aren't tracked by git
+try {
+  const tracked = execSync('git ls-files', { encoding: 'utf-8' });
+  const badFiles = ['.env', '.dev.vars', '.env.local', '.env.production'];
+  const trackedBad = badFiles.filter(f => tracked.split('\n').includes(f));
+  if (trackedBad.length > 0) {
+    console.error('❌ CRITICAL: Secret files tracked by git: ' + trackedBad.join(', '));
+    console.error('   Fix: git rm --cached ' + trackedBad.join(' '));
+    failed = true;
+  }
+} catch (e) {
+  // Not a git repo — skip
+}
+
+if (failed) {
+  console.error('\n🛡️  Gate 0 FAILED. Fix issues above before deploying.');
+  process.exit(1);
+}
+console.log('✅ Gate 0 passed: secret hygiene verified');

package/scripts/gate-1-syntax.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * Gate 1: Syntax Validation
+ * Fast-fail (< 2s). Catches syntax errors before the slower test suite.
+ * - Parses all JS files in public/js/ with acorn
+ * - Runs tsc --noEmit for TypeScript in src/
+ */
+const { parse } = require('acorn');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+let failed = false;
+
+// 1. Parse all JS files in public/js/
+const jsDir = 'public/js';
+if (fs.existsSync(jsDir)) {
+  const jsFiles = fs.readdirSync(jsDir).filter(f => f.endsWith('.js'));
+  for (const file of jsFiles) {
+    const filePath = path.join(jsDir, file);
+    const code = fs.readFileSync(filePath, 'utf-8');
+    try {
+      parse(code, { ecmaVersion: 2022, sourceType: 'script' });
+    } catch (err) {
+      console.error(`❌ Syntax error in ${filePath}:`);
+      console.error(`   Line ${err.loc?.line}, Column ${err.loc?.column}: ${err.message}`);
+      failed = true;
+    }
+  }
+  if (!failed) {
+    console.log(`✅ ${jsFiles.length} JS files parsed successfully`);
+  }
+} else {
+  console.log('⚠  No public/js/ directory found, skipping JS syntax check');
+}
+
+// 2. TypeScript compilation check
+if (fs.existsSync('tsconfig.json')) {
+  try {
+    execSync('npx tsc --noEmit', { encoding: 'utf-8', stdio: 'pipe' });
+    console.log('✅ TypeScript compilation check passed');
+  } catch (err) {
+    console.error('❌ TypeScript compilation errors:');
+    console.error(err.stdout || err.stderr || err.message);
+    failed = true;
+  }
+}
+
+if (failed) {
+  console.error('\n🔴 Gate 1 FAILED. Fix syntax errors before proceeding.');
+  process.exit(1);
+}
+console.log('✅ Gate 1 passed: syntax validation complete');

package/scripts/gate-5-dist-verify.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * Gate 5: Dist Asset Verification
+ * Verifies critical files exist in public/ after build:html + docs:build.
+ * Build can "succeed" but produce an incomplete output directory.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const publicDir = 'public';
+// Critical HTML pages
+const requiredHtml = [
+  'dashboard/index.html',
+];
+
+// Critical JS files
+const requiredJs = [
+  'dashboard/app.js',
+];
+
+// Critical CSS files
+const requiredCss = [
+  'dashboard/style.css',
+];
+
+// Build required file list
+const required = [];
+
+// HTML pages
+for (const html of requiredHtml) {
+  required.push(path.join(publicDir, html));
+}
+
+// JS files
+for (const js of requiredJs) {
+  required.push(path.join(publicDir, js));
+}
+
+// CSS files
+for (const css of requiredCss) {
+  required.push(path.join(publicDir, css));
+}
+
+
+// Check all required files
+const missing = required.filter(f => !fs.existsSync(f));
+
+if (missing.length > 0) {
+  console.error('❌ Missing critical files:');
+  missing.forEach(f => console.error('   ' + f));
+  console.error(`\n🔴 Gate 5 FAILED. ${missing.length} file(s) missing from build output.`);
+  process.exit(1);
+}
+
+console.log(`✅ Gate 5 passed: all ${required.length} critical files present`);

package/scripts/gate-6-smoke-test.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+/**
+ * Gate 6: Post-Deploy Smoke Test
+ * Verifies the deployed site returns HTTP 200.
+ * Usage: node scripts/gate-6-smoke-test.js [optional-url]
+ */
+
+const DEPLOY_URL = process.argv[2] || process.env.DEPLOY_URL || 'https://cody.todyle.com';
+
+async function smokeTest() {
+  console.log(`🔍 Smoke testing: ${DEPLOY_URL}`);
+
+  try {
+    const res = await fetch(DEPLOY_URL);
+    if (res.status === 200) {
+      console.log(`✅ Gate 6 passed: HTTP ${res.status} from ${DEPLOY_URL}`);
+    } else {
+      console.error(`❌ Gate 6 FAILED: HTTP ${res.status} from ${DEPLOY_URL}`);
+      console.error('   ⚠  Consider immediate rollback.');
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(`❌ Gate 6 FAILED: Could not reach ${DEPLOY_URL}`);
+    console.error(`   Error: ${err.message}`);
+    console.error('   ⚠  Consider immediate rollback.');
+    process.exit(1);
+  }
+}
+
+smokeTest();