@lucapimenta/copy-chief-black 1.0.0

package/installer/transpile.js

@@ -0,0 +1,200 @@
+/**
+ * Transpile TypeScript hooks and copy-chief modules to JavaScript
+ * Uses esbuild for fast, Bun-compatible transpilation
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const platform = require('../lib/platform');
+
+function transpileDir(dir, opts = {}) {
+  if (!fs.existsSync(dir)) return { files: 0, errors: [] };
+
+  const tsFiles = findTsFiles(dir);
+  const errors = [];
+  let count = 0;
+
+  // Check for esbuild
+  let esbuildPath;
+  try {
+    esbuildPath = require.resolve('esbuild');
+  } catch {
+    // Try hooks node_modules
+    const hooksEsbuild = path.join(platform.hooksDir(), 'node_modules', '.bin', 'esbuild');
+    if (fs.existsSync(hooksEsbuild)) {
+      esbuildPath = hooksEsbuild;
+    } else {
+      // Install esbuild locally
+      console.log('  Installing esbuild...');
+      try {
+        execSync('npm install --save-dev esbuild', { cwd: dir, stdio: 'pipe' });
+        esbuildPath = path.join(dir, 'node_modules', '.bin', 'esbuild');
+      } catch (e) {
+        return { files: 0, errors: [`Failed to install esbuild: ${e.message}`] };
+      }
+    }
+  }
+
+  for (const tsFile of tsFiles) {
+    const jsFile = tsFile.replace(/\.ts$/, '.js');
+
+    // Skip if .js is newer than .ts
+    if (!opts.force && fs.existsSync(jsFile)) {
+      const tsStat = fs.statSync(tsFile);
+      const jsStat = fs.statSync(jsFile);
+      if (jsStat.mtimeMs > tsStat.mtimeMs) continue;
+    }
+
+    try {
+      // Transpile with esbuild — fast, handles Bun-style imports
+      const esbuildBin = path.join(path.dirname(esbuildPath || ''), '..', '.bin', 'esbuild');
+      const realBin = fs.existsSync(esbuildBin) ? esbuildBin : 'npx esbuild';
+
+      execSync(
+        `${realBin} "${tsFile}" --outfile="${jsFile}" --format=cjs --platform=node --target=node18`,
+        { cwd: dir, stdio: 'pipe' }
+      );
+
+      // Post-process: fix .ts require paths and shebang
+      postProcessJs(jsFile);
+      count++;
+    } catch (e) {
+      // Fallback: simple strip-types transpilation
+      try {
+        const content = fs.readFileSync(tsFile, 'utf8');
+        const stripped = stripTypes(content);
+        fs.writeFileSync(jsFile, stripped, 'utf8');
+        count++;
+      } catch (e2) {
+        errors.push(`${path.basename(tsFile)}: ${e2.message}`);
+      }
+    }
+  }
+
+  return { files: count, errors };
+}
+
+/**
+ * Post-process transpiled JS:
+ * 1. Replace .ts extensions in require() paths with .js
+ * 2. Replace #!/usr/bin/env bun shebang with node
+ */
+function postProcessJs(jsFile) {
+  let content = fs.readFileSync(jsFile, 'utf8');
+  let changed = false;
+
+  // Fix shebang: bun → node
+  if (content.startsWith('#!/usr/bin/env bun')) {
+    content = content.replace('#!/usr/bin/env bun', '#!/usr/bin/env node');
+    changed = true;
+  }
+
+  // Fix .ts extensions in require paths → .js
+  const tsRequireRe = /require\(["']([^"']*?)\.ts["']\)/g;
+  if (tsRequireRe.test(content)) {
+    content = content.replace(tsRequireRe, (_, mod) => `require("${mod}.js")`);
+    changed = true;
+  }
+
+  if (changed) {
+    fs.writeFileSync(jsFile, content, 'utf8');
+  }
+}
+
+function findTsFiles(dir) {
+  const results = [];
+  function walk(d) {
+    let entries;
+    try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (e.name === 'node_modules' || e.name === 'compiled') continue;
+      const full = path.join(d, e.name);
+      if (e.isDirectory()) walk(full);
+      else if (e.name.endsWith('.ts') && !e.name.endsWith('.d.ts')) results.push(full);
+    }
+  }
+  walk(dir);
+  return results;
+}
+
+/**
+ * Simple type-stripping for TypeScript → JavaScript
+ * Handles: type annotations, interfaces, type imports, generics
+ */
+function stripTypes(code) {
+  let result = code;
+
+  // Remove shebang
+  result = result.replace(/^#!.*\n/, '');
+
+  // Remove type-only imports
+  result = result.replace(/^import\s+type\s+.*;\s*$/gm, '');
+
+  // Convert import { type X, Y } to import { Y }
+  result = result.replace(/import\s*\{([^}]+)\}/g, (match, imports) => {
+    const cleaned = imports
+      .split(',')
+      .filter(i => !i.trim().startsWith('type '))
+      .join(',');
+    return cleaned.trim() ? `import {${cleaned}}` : '';
+  });
+
+  // Remove interface/type declarations
+  result = result.replace(/^(export\s+)?(interface|type)\s+\w+[^{]*\{[^}]*\}\s*$/gm, '');
+
+  // Remove type annotations from variables: `: Type`
+  result = result.replace(/:\s*(string|number|boolean|void|any|null|undefined|unknown|never|Record<[^>]+>|Array<[^>]+>|\w+\[\]|{\s*[^}]*})\s*([=;,)])/g, '$2');
+
+  // Remove return type annotations
+  result = result.replace(/\):\s*\w+(\[\])?\s*\{/g, ') {');
+  result = result.replace(/\):\s*\w+(\[\])?\s*=>/g, ') =>');
+
+  // Remove generic type params
+  result = result.replace(/<[A-Z]\w*(\s*,\s*[A-Z]\w*)*>/g, '');
+
+  // Remove `as Type` casts
+  result = result.replace(/\s+as\s+\w+(\[\])?/g, '');
+
+  // Convert `import ... from '../module.ts'` to `require`
+  result = result.replace(/import\s+(\{[^}]+\})\s+from\s+['"]([^'"]+)['"]\s*;?/g, (_, imports, mod) => {
+    const cleanMod = mod.replace(/\.ts$/, '');
+    const names = imports.replace(/[{}]/g, '').trim();
+    return `const ${imports.replace(/[{}]/g, '').trim().includes(',') ? `{ ${names} }` : names} = require('${cleanMod}');`;
+  });
+
+  // Convert default imports
+  result = result.replace(/import\s+(\w+)\s+from\s+['"]([^'"]+)['"]\s*;?/g, (_, name, mod) => {
+    const cleanMod = mod.replace(/\.ts$/, '');
+    return `const ${name} = require('${cleanMod}');`;
+  });
+
+  return result;
+}
+
+async function transpileAll(opts = {}) {
+  console.log('Transpiling TypeScript files...\n');
+
+  // 1. Hooks
+  const hooksResult = transpileDir(platform.hooksDir(), opts);
+  console.log(`  Hooks: ${hooksResult.files} transpiled`);
+  if (hooksResult.errors.length) {
+    for (const e of hooksResult.errors) console.log(`    ⚠️  ${e}`);
+  }
+
+  // 2. Copy-chief modules
+  const ccResult = transpileDir(platform.copyChiefDir(), opts);
+  console.log(`  Copy-chief: ${ccResult.files} transpiled`);
+  if (ccResult.errors.length) {
+    for (const e of ccResult.errors) console.log(`    ⚠️  ${e}`);
+  }
+
+  const totalErrors = hooksResult.errors.length + ccResult.errors.length;
+  const total = hooksResult.files + ccResult.files;
+  console.log(`\n${totalErrors === 0 ? '✅' : '⚠️ '} ${total} files transpiled, ${totalErrors} errors`);
+
+  return totalErrors === 0;
+}
+
+module.exports = { transpileDir, transpileAll, stripTypes };

package/installer/update.js

@@ -0,0 +1,57 @@
+/**
+ * Copy Chief BLACK — Update
+ * Merges new framework version preserving customizations
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const platform = require('../lib/platform');
+const settingsBuilder = require('../lib/settings-builder');
+
+async function update(opts = {}) {
+  console.log('Copy Chief BLACK — Update\n');
+
+  const claudeHome = platform.claudeHome();
+  if (!fs.existsSync(claudeHome)) {
+    console.error('❌ No installation found. Run: copy-chief-black install');
+    process.exit(1);
+  }
+
+  // Backup before update
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const backupDir = `${claudeHome}-pre-update-${timestamp}`;
+  fs.cpSync(claudeHome, backupDir, { recursive: true });
+  console.log(`  Backup: ${backupDir}`);
+
+  // Update framework files
+  const frameworkDir = path.join(__dirname, '..', 'framework');
+  if (fs.existsSync(frameworkDir)) {
+    const items = ['.aios-core', 'hooks', 'agents', 'plugins', 'schemas'];
+    for (const item of items) {
+      const src = path.join(frameworkDir, item);
+      const dest = path.join(claudeHome, item);
+      if (!fs.existsSync(src)) continue;
+      fs.cpSync(src, dest, { recursive: true, force: opts.force || false });
+      console.log(`  Updated: ${item}/`);
+    }
+  }
+
+  // Regenerate settings.json (merge mode)
+  settingsBuilder.writeSettings({ force: false });
+  console.log('  Merged: settings.json');
+
+  // Reinstall deps
+  const aiosCore = platform.aiosCoreDir();
+  const { execSync } = require('child_process');
+  try {
+    execSync('npm install --production', { cwd: aiosCore, stdio: 'pipe' });
+    console.log('  Dependencies updated ✓');
+  } catch (e) {
+    console.error(`  ⚠️  npm install: ${e.message}`);
+  }
+
+  console.log('\n✅ Update complete.');
+}
+
+module.exports = { update };

package/installer/verify.js

@@ -0,0 +1,124 @@
+/**
+ * Copy Chief BLACK — Verification
+ * Checks installation integrity
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const platform = require('../lib/platform');
+const settingsBuilder = require('../lib/settings-builder');
+
+async function verify(opts = {}) {
+  const quiet = opts.quiet || false;
+  const fix = opts.fix || false;
+  let issues = 0;
+  let fixed = 0;
+
+  if (!quiet) console.log('Copy Chief BLACK — Verification\n');
+
+  // 1. Check directories exist
+  const requiredDirs = [
+    { path: platform.claudeHome(), label: 'Claude Home' },
+    { path: platform.aiosCoreDir(), label: 'AIOS Core' },
+    { path: platform.copyChiefDir(), label: 'Copy Chief modules' },
+    { path: platform.hooksDir(), label: 'Hooks directory' },
+  ];
+
+  for (const dir of requiredDirs) {
+    if (fs.existsSync(dir.path)) {
+      if (!quiet) console.log(`  ✓ ${dir.label}: ${dir.path}`);
+    } else {
+      issues++;
+      if (!quiet) console.log(`  ✗ ${dir.label} MISSING: ${dir.path}`);
+      if (fix) {
+        fs.mkdirSync(dir.path, { recursive: true });
+        fixed++;
+      }
+    }
+  }
+
+  // 2. Check settings.json
+  const settingsPath = path.join(platform.claudeHome(), 'settings.json');
+  const settingsIssues = settingsBuilder.validateSettings(settingsPath);
+  if (settingsIssues.length === 0) {
+    if (!quiet) console.log('  ✓ settings.json valid');
+  } else {
+    issues += settingsIssues.length;
+    for (const issue of settingsIssues) {
+      if (!quiet) console.log(`  ✗ settings.json: ${issue}`);
+    }
+  }
+
+  // 3. Check js-yaml available
+  try {
+    platform.getYaml();
+    if (!quiet) console.log('  ✓ js-yaml available');
+  } catch {
+    issues++;
+    if (!quiet) console.log('  ✗ js-yaml NOT available');
+  }
+
+  // 4. Check core modules
+  const coreModules = [
+    'index.js',
+    'orchestration/helix-orchestrator.js',
+    'execution/copy-workflow-executor.js',
+    'gates/quality-gate-manager.ts',
+    'state/session-state.ts',
+  ];
+
+  const ccDir = platform.copyChiefDir();
+  let moduleOk = 0;
+  for (const mod of coreModules) {
+    if (fs.existsSync(path.join(ccDir, mod))) {
+      moduleOk++;
+    } else {
+      issues++;
+      if (!quiet) console.log(`  ✗ Missing module: copy-chief/${mod}`);
+    }
+  }
+  if (!quiet && moduleOk === coreModules.length) {
+    console.log(`  ✓ Core modules: ${moduleOk}/${coreModules.length}`);
+  }
+
+  // 5. Check hooks exist (sample check)
+  const criticalHooks = [
+    'synapse-engine.cjs',
+    'helix-orchestrator-boot.cjs',
+    'agent-activation-hook.cjs',
+    'pipeline-intent-detector.cjs',
+    'handoff-validator-hook.cjs',
+  ];
+
+  const hDir = platform.hooksDir();
+  let hookOk = 0;
+  for (const hook of criticalHooks) {
+    if (fs.existsSync(path.join(hDir, hook))) {
+      hookOk++;
+    } else {
+      issues++;
+      if (!quiet) console.log(`  ✗ Missing critical hook: ${hook}`);
+    }
+  }
+  if (!quiet && hookOk === criticalHooks.length) {
+    console.log(`  ✓ Critical hooks: ${hookOk}/${criticalHooks.length}`);
+  }
+
+  // 6. Count total hooks
+  if (fs.existsSync(hDir)) {
+    const allHooks = fs.readdirSync(hDir).filter(f =>
+      f.endsWith('.cjs') || f.endsWith('.js') || f.endsWith('.ts')
+    );
+    if (!quiet) console.log(`  ✓ Total hooks: ${allHooks.length}`);
+  }
+
+  // Summary
+  if (!quiet) {
+    console.log(`\n${issues === 0 ? '✅' : '⚠️ '} ${issues} issue(s) found${fix ? `, ${fixed} fixed` : ''}`);
+  }
+
+  return issues === 0;
+}
+
+module.exports = { verify };

package/lib/platform.js

@@ -0,0 +1,155 @@
+/**
+ * Cross-platform helpers for Copy Chief BLACK
+ * Replaces: /dev/stdin, process.env.HOME, hardcoded paths, shell commands
+ */
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+// ─── Path Resolution ───────────────────────────────────────────────
+
+function homeDir() { return os.homedir(); }
+function claudeHome() { return path.join(homeDir(), '.claude'); }
+function aiosCoreDir() { return path.join(claudeHome(), '.aios-core'); }
+function copyChiefDir() { return path.join(aiosCoreDir(), 'copy-chief'); }
+function hooksDir() { return path.join(claudeHome(), 'hooks'); }
+
+function ecosystemRoot() {
+  if (process.env.ECOSYSTEM_ROOT) return process.env.ECOSYSTEM_ROOT;
+  let dir = process.cwd();
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    if (fs.existsSync(path.join(dir, '.synapse'))) return dir;
+    dir = path.dirname(dir);
+  }
+  return path.join(homeDir(), 'copywriting-ecosystem');
+}
+
+function resolvePath(p) {
+  if (p.startsWith('~/') || p === '~') return path.join(homeDir(), p.slice(2));
+  return path.resolve(p);
+}
+
+function normalizePath(p) { return p.split(/[/\\]/).join(path.sep); }
+
+// ─── Stdin Reading ─────────────────────────────────────────────────
+
+function readStdinSync() {
+  try { return fs.readFileSync(0, 'utf8'); }
+  catch (e) { return ''; }
+}
+
+function readStdinJSON() {
+  const raw = readStdinSync();
+  if (!raw || !raw.trim()) return null;
+  try { return JSON.parse(raw); }
+  catch (e) { return null; }
+}
+
+// ─── YAML Helpers ──────────────────────────────────────────────────
+
+let _yaml = null;
+
+function getYaml() {
+  if (_yaml) return _yaml;
+  try { _yaml = require('js-yaml'); }
+  catch {
+    try { _yaml = require(path.join(aiosCoreDir(), 'node_modules', 'js-yaml')); }
+    catch { throw new Error('js-yaml not found. Run: npm install js-yaml'); }
+  }
+  return _yaml;
+}
+
+function readYaml(filePath) {
+  const yaml = getYaml();
+  const resolved = resolvePath(filePath);
+  if (!fs.existsSync(resolved)) return null;
+  return yaml.load(fs.readFileSync(resolved, 'utf8')) || {};
+}
+
+function writeYaml(filePath, data) {
+  const yaml = getYaml();
+  const resolved = resolvePath(filePath);
+  const dir = path.dirname(resolved);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(resolved, yaml.dump(data, { lineWidth: -1 }), 'utf8');
+}
+
+// ─── File System Helpers ───────────────────────────────────────────
+
+function ensureDir(dirPath) {
+  const resolved = resolvePath(dirPath);
+  if (!fs.existsSync(resolved)) fs.mkdirSync(resolved, { recursive: true });
+  return resolved;
+}
+
+function readFileSafe(filePath, fallback = '') {
+  try { return fs.readFileSync(resolvePath(filePath), 'utf8'); }
+  catch { return fallback; }
+}
+
+function isWindows() { return process.platform === 'win32'; }
+function isMacOS() { return process.platform === 'darwin'; }
+function nodeBin() { return process.execPath; }
+
+function buildPath() {
+  const paths = [];
+  if (isWindows()) {
+    paths.push(path.dirname(process.execPath));
+    const gitPath = findExecutable('git');
+    if (gitPath) paths.push(path.dirname(gitPath));
+    paths.push(process.env.SystemRoot ? path.join(process.env.SystemRoot, 'System32') : 'C:\\Windows\\System32');
+  } else {
+    const homeLocal = path.join(homeDir(), '.local', 'bin');
+    if (fs.existsSync(homeLocal)) paths.push(homeLocal);
+    if (fs.existsSync('/opt/homebrew/bin')) paths.push('/opt/homebrew/bin');
+    if (fs.existsSync('/usr/local/bin')) paths.push('/usr/local/bin');
+    paths.push('/usr/bin', '/bin', '/usr/sbin', '/sbin');
+  }
+  return paths.filter(Boolean).join(path.delimiter);
+}
+
+function findExecutable(name) {
+  const ext = isWindows() ? ['.exe', '.cmd', '.bat', ''] : [''];
+  const pathDirs = (process.env.PATH || '').split(path.delimiter);
+  for (const dir of pathDirs) {
+    for (const e of ext) {
+      const full = path.join(dir, name + e);
+      if (fs.existsSync(full)) return full;
+    }
+  }
+  return null;
+}
+
+// ─── Hook Response Helpers ─────────────────────────────────────────
+
+function hookResponse(obj) { process.stdout.write(JSON.stringify(obj)); }
+function hookPass() { /* empty = pass */ }
+function hookBlock(reason) { hookResponse({ decision: 'block', reason }); }
+function hookMessage(message) { hookResponse({ message }); }
+
+// ─── Offer Detection ──────────────────────────────────────────────
+
+function detectOffer() {
+  const cwd = process.cwd();
+  const eco = ecosystemRoot();
+  const rel = path.relative(eco, cwd);
+  const parts = rel.split(path.sep);
+  if (parts.length >= 2 && !parts[0].startsWith('.')) {
+    return { niche: parts[0], offer: parts[1], path: path.join(eco, parts[0], parts[1]) };
+  }
+  return null;
+}
+
+module.exports = {
+  homeDir, claudeHome, aiosCoreDir, copyChiefDir, hooksDir,
+  ecosystemRoot, resolvePath, normalizePath,
+  readStdinSync, readStdinJSON,
+  getYaml, readYaml, writeYaml,
+  ensureDir, readFileSafe,
+  isWindows, isMacOS, nodeBin, buildPath, findExecutable,
+  hookResponse, hookPass, hookBlock, hookMessage,
+  detectOffer,
+};