agent-skill-kit 3.9.135

package/.agent/skills/code-constitution/scripts/audit_pr.ts

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+// @ts-nocheck
+/**
+ * PikaKit PR Audit Tool
+ * 
+ * Audits a Git branch or PR for doctrine compliance
+ * 
+ * Usage:
+ *   node scripts/audit_pr.js <branch-name>
+ *   node scripts/audit_pr.js --current  (audit current branch vs main)
+ * 
+ * Exit codes:
+ *   0 = All checks passed
+ *   1 = Violations found
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    magenta: '\x1b[35m',
+    dim: '\x1b[2m',
+    bold: '\x1b[1m',
+};
+
+class PRAuditor {
+    constructor(targetBranch, baseBranch = 'main') {
+        this.targetBranch = targetBranch;
+        this.baseBranch = baseBranch;
+        this.changedFiles = [];
+        this.violations = [];
+    }
+
+    getChangedFiles() {
+        try {
+            const diff = execSync(
+                `git diff --name-only ${this.baseBranch}...${this.targetBranch}`,
+                { encoding: 'utf-8' }
+            );
+
+            this.changedFiles = diff
+                .split('\n')
+                .filter(f => f.trim())
+                .filter(f => f.match(/\.(ts|tsx|js|jsx)$/))
+                .filter(f => !f.includes('node_modules'))
+                .filter(f => !f.includes('.test.'))
+                .filter(f => !f.includes('.spec.'));
+
+            return this.changedFiles;
+        } catch (error) {
+            console.error(colors.red + 'Error getting changed files:' + colors.reset, error.message);
+            process.exit(1);
+        }
+    }
+
+    categorizePR() {
+        const categories = {
+            backend: false,
+            frontend: false,
+            api: false,
+            chart: false,
+            mobile: false,
+            data: false,
+        };
+
+        for (const file of this.changedFiles) {
+            if (file.match(/api\//)) categories.api = true;
+            if (file.match(/lib\/|server\/|db\//)) categories.backend = true;
+            if (file.match(/components\/|app\/|pages\//)) categories.frontend = true;
+            if (file.match(/chart|graph|ohlc|candle/i)) categories.chart = true;
+            if (file.match(/mobile|gesture|swipe|scroll/i)) categories.mobile = true;
+            if (file.match(/data|price|market|coin/i)) categories.data = true;
+        }
+
+        return categories;
+    }
+
+    getApplicableDoctrines(categories) {
+        const doctrines = [
+            'constitution/master-constitution.md',
+        ];
+
+        if (categories.backend || categories.api) {
+            doctrines.push('doctrines/architecture/architecture-doctrine.md');
+            doctrines.push('doctrines/backend/backend-data-engine-doctrine.md');
+        }
+
+        if (categories.chart || categories.data) {
+            doctrines.push('doctrines/data/data-integrity-doctrine.md');
+        }
+
+        if (categories.frontend || categories.mobile) {
+            doctrines.push('doctrines/frontend/frontend-mobile-doctrine.md');
+        }
+
+        if (categories.mobile) {
+            doctrines.push('doctrines/frontend/interaction-patterns-doctrine.md');
+        }
+
+        doctrines.push('doctrines/performance/performance-doctrine.md');
+        doctrines.push('doctrines/commercial/commercial-guardrails-doctrine.md');
+
+        return doctrines;
+    }
+
+    async auditFiles() {
+        const validatorPath = path.join(__dirname, 'validate_doctrine.js');
+
+        for (const file of this.changedFiles) {
+            if (!fs.existsSync(file)) {
+                console.log(colors.yellow + `⚠️  File deleted: ${file}` + colors.reset);
+                continue;
+            }
+
+            console.log(colors.dim + `\nValidating: ${file}` + colors.reset);
+
+            try {
+                execSync(`node "${validatorPath}" "${file}"`, {
+                    stdio: 'inherit',
+                });
+            } catch (error) {
+                this.violations.push(file);
+            }
+        }
+    }
+
+    printSummary() {
+        const categories = this.categorizePR();
+        const doctrines = this.getApplicableDoctrines(categories);
+
+        console.log('\n' + colors.magenta + '═'.repeat(70) + colors.reset);
+        console.log(colors.magenta + colors.bold + `PikaKit PR Audit Report` + colors.reset);
+        console.log(colors.magenta + '═'.repeat(70) + colors.reset + '\n');
+
+        console.log(colors.cyan + `Branch: ${this.targetBranch}` + colors.reset);
+        console.log(colors.dim + `Base: ${this.baseBranch}` + colors.reset);
+        console.log(colors.dim + `Files changed: ${this.changedFiles.length}` + colors.reset);
+        console.log();
+
+        console.log(colors.bold + 'PR Categories:' + colors.reset);
+        Object.entries(categories).forEach(([cat, val]) => {
+            if (val) {
+                console.log(`  ✓ ${cat}`);
+            }
+        });
+        console.log();
+
+        console.log(colors.bold + 'Applicable Doctrines:' + colors.reset);
+        doctrines.forEach(d => {
+            console.log(colors.dim + `  • ${d}` + colors.reset);
+        });
+        console.log();
+
+        if (this.violations.length === 0) {
+            console.log(colors.green + '✅ All files passed doctrine validation!' + colors.reset);
+        } else {
+            console.log(colors.red + `❌ ${this.violations.length} file(s) with violations:` + colors.reset);
+            this.violations.forEach(file => {
+                console.log(colors.red + `  • ${file}` + colors.reset);
+            });
+        }
+
+        console.log('\n' + colors.magenta + '═'.repeat(70) + colors.reset + '\n');
+    }
+
+    async run() {
+        console.log(colors.cyan + '\n🔍 Starting PikaKit PR Audit...\n' + colors.reset);
+
+        this.getChangedFiles();
+
+        if (this.changedFiles.length === 0) {
+            console.log(colors.yellow + 'No relevant files changed.' + colors.reset);
+            return 0;
+        }
+
+        console.log(colors.dim + `Found ${this.changedFiles.length} file(s) to audit\n` + colors.reset);
+
+        await this.auditFiles();
+        this.printSummary();
+
+        return this.violations.length > 0 ? 1 : 0;
+    }
+}
+
+// Main execution
+const arg = process.argv[2];
+
+if (!arg) {
+    console.error('Usage: node audit_pr.js <branch-name>');
+    console.error('       node audit_pr.js --current');
+    process.exit(1);
+}
+
+let targetBranch;
+if (arg === '--current') {
+    try {
+        targetBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+    } catch (error) {
+        console.error(colors.red + 'Error getting current branch' + colors.reset);
+        process.exit(1);
+    }
+} else {
+    targetBranch = arg;
+}
+
+const auditor = new PRAuditor(targetBranch);
+auditor.run().then(exitCode => {
+    process.exit(exitCode);
+});

package/.agent/skills/code-constitution/scripts/check_boundaries.ts

@@ -0,0 +1,134 @@
+// @ts-nocheck
+/**
+ * Code Constitution — Boundary Checker
+ * Validates system boundaries and ownership rules.
+ *
+ * Usage:
+ *   npx tsx check_boundaries.ts <directory>
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+interface BoundaryViolation {
+  file: string;
+  line: number;
+  rule: string;
+  severity: 'error' | 'warning';
+  message: string;
+}
+
+interface BoundaryRule {
+  pattern: RegExp;
+  rule: string;
+  message: string;
+  severity: 'error' | 'warning';
+}
+
+const BOUNDARY_RULES: BoundaryRule[] = [
+  {
+    pattern: /import\s+.*from\s+['"]\.\.\//,
+    rule: 'NO_PARENT_IMPORT',
+    message: 'Importing from parent directory may violate ownership boundaries',
+    severity: 'warning',
+  },
+  {
+    pattern: /require\s*\(\s*['"]\.\.\//,
+    rule: 'NO_PARENT_REQUIRE',
+    message: 'Requiring from parent directory may violate ownership boundaries',
+    severity: 'warning',
+  },
+  {
+    pattern: /process\.env\.\w+/,
+    rule: 'ENV_ACCESS',
+    message: 'Direct environment variable access — ensure ownership is correct',
+    severity: 'warning',
+  },
+  {
+    pattern: /fs\.(writeFile|unlink|rmdir|rm)\s*\(/,
+    rule: 'DESTRUCTIVE_FS',
+    message: 'Destructive filesystem operation — verify boundary ownership',
+    severity: 'error',
+  },
+  {
+    pattern: /child_process|exec\s*\(|execSync|spawn/,
+    rule: 'PROCESS_EXECUTION',
+    message: 'Process execution detected — verify this is within skill boundaries',
+    severity: 'warning',
+  },
+];
+
+function scanFile(filePath: string): BoundaryViolation[] {
+  const violations: BoundaryViolation[] = [];
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n');
+
+  lines.forEach((line, index) => {
+    for (const rule of BOUNDARY_RULES) {
+      if (rule.pattern.test(line)) {
+        violations.push({
+          file: filePath,
+          line: index + 1,
+          rule: rule.rule,
+          severity: rule.severity,
+          message: rule.message,
+        });
+      }
+    }
+  });
+
+  return violations;
+}
+
+function scanDirectory(dirPath: string): BoundaryViolation[] {
+  const violations: BoundaryViolation[] = [];
+  const extensions = ['.ts', '.js', '.tsx', '.jsx'];
+
+  function walk(dir: string): void {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!['node_modules', '.git', 'dist', '.agent'].includes(entry.name)) {
+          walk(fullPath);
+        }
+      } else if (extensions.some(ext => entry.name.endsWith(ext))) {
+        violations.push(...scanFile(fullPath));
+      }
+    }
+  }
+
+  walk(dirPath);
+  return violations;
+}
+
+function main(): void {
+  const targetDir = process.argv[2] || '.';
+
+  if (!fs.existsSync(targetDir)) {
+    console.error(JSON.stringify({
+      status: 'error',
+      error: { code: 'ERR_DIR_NOT_FOUND', message: `Directory not found: ${targetDir}`, recoverable: false }
+    }));
+    process.exit(1);
+  }
+
+  const violations = scanDirectory(targetDir);
+  const errors = violations.filter(v => v.severity === 'error');
+  const warnings = violations.filter(v => v.severity === 'warning');
+
+  console.log(JSON.stringify({
+    status: errors.length > 0 ? 'error' : 'success',
+    data: {
+      directory: targetDir,
+      totalViolations: violations.length,
+      errors: errors.length,
+      warnings: warnings.length,
+      violations: violations.slice(0, 50), // Cap at 50
+    }
+  }));
+
+  process.exit(errors.length > 0 ? 1 : 0);
+}
+
+main();

package/.agent/skills/code-constitution/scripts/learn.ts

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+// @ts-nocheck
+/**
+ * PikaKit Governance Learning Script
+ *
+ * Adds new lessons to the governance knowledge base.
+ * Usage:
+ *   node learn.js --add --pattern "regex" --message "why bad"
+ *   node learn.js --list
+ *
+ * @version 2.0.0
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ============================================================================
+// CONFIGURATION
+// ============================================================================
+
+const KNOWLEDGE_PATH = path.join(__dirname, '..', 'knowledge', 'lessons-learned.yaml');
+
+// ============================================================================
+// YAML HELPERS (no external dependency)
+// ============================================================================
+
+function parseYaml(content) {
+    const result = { version: '1.0.0', last_updated: '', lessons: [] };
+    const lines = content.split('\n');
+    let currentLesson = null;
+
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('version:')) result.version = trimmed.split(':')[1].trim().replace(/"/g, '');
+        if (trimmed.startsWith('last_updated:')) result.last_updated = trimmed.split(':', 2)[1].trim().replace(/"/g, '');
+        if (trimmed.startsWith('- id:')) {
+            if (currentLesson) result.lessons.push(currentLesson);
+            currentLesson = { id: trimmed.replace('- id:', '').trim() };
+        }
+        if (currentLesson && trimmed.startsWith('pattern:')) currentLesson.pattern = trimmed.replace('pattern:', '').trim().replace(/"/g, '');
+        if (currentLesson && trimmed.startsWith('message:')) currentLesson.message = trimmed.replace('message:', '').trim().replace(/"/g, '');
+        if (currentLesson && trimmed.startsWith('severity:')) currentLesson.severity = trimmed.replace('severity:', '').trim();
+        if (currentLesson && trimmed.startsWith('addedAt:')) currentLesson.addedAt = trimmed.replace('addedAt:', '').trim().replace(/"/g, '');
+    }
+    if (currentLesson) result.lessons.push(currentLesson);
+    return result;
+}
+
+function toYaml(data) {
+    let out = `version: "${data.version}"\n`;
+    out += `last_updated: "${data.last_updated}"\n`;
+
+    if (!data.lessons || data.lessons.length === 0) {
+        out += 'lessons: []\n';
+        return out;
+    }
+
+    out += 'lessons:\n';
+    for (const l of data.lessons) {
+        out += `  - id: ${l.id}\n`;
+        out += `    pattern: "${l.pattern}"\n`;
+        out += `    message: "${l.message}"\n`;
+        out += `    severity: ${l.severity}\n`;
+        out += `    addedAt: "${l.addedAt}"\n`;
+    }
+    return out;
+}
+
+// ============================================================================
+// CORE FUNCTIONS
+// ============================================================================
+
+function loadKnowledge() {
+    try {
+        if (!fs.existsSync(KNOWLEDGE_PATH)) {
+            const initial = { version: '1.0.0', last_updated: '', lessons: [] };
+            fs.mkdirSync(path.dirname(KNOWLEDGE_PATH), { recursive: true });
+            fs.writeFileSync(KNOWLEDGE_PATH, toYaml(initial), 'utf8');
+            return initial;
+        }
+        const content = fs.readFileSync(KNOWLEDGE_PATH, 'utf8');
+        return parseYaml(content);
+    } catch (error) {
+        console.error('❌ Failed to load knowledge base:', error.message);
+        process.exit(1);
+    }
+}
+
+function saveKnowledge(data) {
+    try {
+        data.last_updated = new Date().toISOString();
+        fs.writeFileSync(KNOWLEDGE_PATH, toYaml(data), 'utf8');
+        console.log('✅ Knowledge base updated successfully.');
+    } catch (error) {
+        console.error('❌ Failed to save knowledge base:', error.message);
+        process.exit(1);
+    }
+}
+
+function addLesson(pattern, message, severity = 'WARNING') {
+    const db = loadKnowledge();
+
+    // Validate Regex
+    try {
+        new RegExp(pattern);
+    } catch (e) {
+        console.error('❌ Invalid Regex pattern:', e.message);
+        process.exit(1);
+    }
+
+    const id = `LEARN-${String(db.lessons.length + 1).padStart(3, '0')}`;
+
+    db.lessons.push({
+        id,
+        pattern,
+        message,
+        severity,
+        addedAt: new Date().toISOString(),
+    });
+
+    saveKnowledge(db);
+
+    console.log(`\n🎓 Lesson Learned: [${id}]`);
+    console.log(`   Pattern: /${pattern}/`);
+    console.log(`   Message: ${message}`);
+    console.log('\n⚡ PikaKit Governance Learning Engine v2.0.0');
+}
+
+function listLessons() {
+    const db = loadKnowledge();
+    if (db.lessons.length === 0) {
+        console.log('ℹ️  No lessons learned yet.');
+        return;
+    }
+
+    console.log('\n🧠 PikaKit Governance Knowledge Base:\n');
+    for (const l of db.lessons) {
+        console.log(`  [${l.id}] /${l.pattern}/ -> ${l.message} (${l.severity})`);
+    }
+    console.log('');
+}
+
+// ============================================================================
+// CLI
+// ============================================================================
+
+function printHelp() {
+    console.log(`
+PikaKit Governance Learning Tool v2.0.0
+
+USAGE:
+  node learn.js --add --pattern "..." --message "..."
+  node learn.js --list
+  node learn.js --help
+
+OPTIONS:
+  --add       Add a new lesson
+  --pattern   Regex pattern to flag
+  --message   Explanation message
+  --severity  Severity (WARNING/ERROR), default WARNING
+  --list      List all learned lessons
+`);
+}
+
+// Main
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.length === 0) {
+    printHelp();
+    process.exit(0);
+}
+
+if (args.includes('--list')) {
+    listLessons();
+    process.exit(0);
+}
+
+if (args.includes('--add')) {
+    const pIdx = args.indexOf('--pattern');
+    const mIdx = args.indexOf('--message');
+    const sIdx = args.indexOf('--severity');
+
+    if (pIdx === -1 || mIdx === -1) {
+        console.error('❌ --pattern and --message are required for --add');
+        process.exit(1);
+    }
+
+    const pattern = args[pIdx + 1];
+    const message = args[mIdx + 1];
+    const severity = sIdx !== -1 ? args[sIdx + 1] : 'WARNING';
+
+    if (!pattern || !message) {
+        console.error('❌ Missing values for pattern/message');
+        process.exit(1);
+    }
+
+    addLesson(pattern, message, severity);
+}