aw-ecc 1.4.21

package/scripts/cursor-aw-hooks/pre-compact.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const { readStdin } = require('./adapter');
+const { runNamedCursorAwPhase } = require('./aw-phase-adapter');
+const { PHASE_NAMES } = require('./shared/aw-phase-definitions');
+
+readStdin().then(raw => {
+  return runNamedCursorAwPhase({
+    phaseName: PHASE_NAMES.PRE_COMPACT,
+    raw,
+  }).then(output => process.stdout.write(output));
+}).catch(() => process.exit(0));

package/scripts/cursor-aw-hooks/session-end.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const { readStdin } = require('./adapter');
+const { runNamedCursorAwPhase } = require('./aw-phase-adapter');
+const { PHASE_NAMES } = require('./shared/aw-phase-definitions');
+
+readStdin().then(raw => {
+  return runNamedCursorAwPhase({
+    phaseName: PHASE_NAMES.SESSION_END,
+    raw,
+  }).then(output => process.stdout.write(output));
+}).catch(() => process.exit(0));

package/scripts/cursor-aw-hooks/session-start.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const { readStdin } = require('./adapter');
+const { runNamedCursorAwPhase } = require('./aw-phase-adapter');
+const { PHASE_NAMES } = require('./shared/aw-phase-definitions');
+
+readStdin().then(raw => {
+  return runNamedCursorAwPhase({
+    phaseName: PHASE_NAMES.SESSION_START,
+    raw,
+  }).then(output => process.stdout.write(output));
+}).catch(() => process.exit(0));

package/scripts/cursor-aw-hooks/stop.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const { readStdin } = require('./adapter');
+const { runNamedCursorAwPhase } = require('./aw-phase-adapter');
+const { PHASE_NAMES } = require('./shared/aw-phase-definitions');
+
+readStdin().then(raw => {
+  return runNamedCursorAwPhase({
+    phaseName: PHASE_NAMES.STOP,
+    raw,
+  }).then(output => process.stdout.write(output));
+}).catch(() => process.exit(0));

package/scripts/doctor.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+const { buildDoctorReport } = require('./lib/install-lifecycle');
+const { SUPPORTED_INSTALL_TARGETS } = require('./lib/install-manifests');
+
+function showHelp(exitCode = 0) {
+  console.log(`
+Usage: node scripts/doctor.js [--target <${SUPPORTED_INSTALL_TARGETS.join('|')}>] [--json]
+
+Diagnose drift and missing managed files for ECC install-state in the current context.
+`);
+  process.exit(exitCode);
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const parsed = {
+    targets: [],
+    json: false,
+    help: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--target') {
+      parsed.targets.push(args[index + 1] || null);
+      index += 1;
+    } else if (arg === '--json') {
+      parsed.json = true;
+    } else if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
+function statusLabel(status) {
+  if (status === 'ok') {
+    return 'OK';
+  }
+
+  if (status === 'warning') {
+    return 'WARNING';
+  }
+
+  if (status === 'error') {
+    return 'ERROR';
+  }
+
+  return status.toUpperCase();
+}
+
+function printHuman(report) {
+  if (report.results.length === 0) {
+    console.log('No ECC install-state files found for the current home/project context.');
+    return;
+  }
+
+  console.log('Doctor report:\n');
+  for (const result of report.results) {
+    console.log(`- ${result.adapter.id}`);
+    console.log(`  Status: ${statusLabel(result.status)}`);
+    console.log(`  Install-state: ${result.installStatePath}`);
+
+    if (result.issues.length === 0) {
+      console.log('  Issues: none');
+      continue;
+    }
+
+    for (const issue of result.issues) {
+      console.log(`  - [${issue.severity}] ${issue.code}: ${issue.message}`);
+    }
+  }
+
+  console.log(`\nSummary: checked=${report.summary.checkedCount}, ok=${report.summary.okCount}, warnings=${report.summary.warningCount}, errors=${report.summary.errorCount}`);
+}
+
+function main() {
+  try {
+    const options = parseArgs(process.argv);
+    if (options.help) {
+      showHelp(0);
+    }
+
+    const report = buildDoctorReport({
+      repoRoot: require('path').join(__dirname, '..'),
+      homeDir: process.env.HOME,
+      projectRoot: process.cwd(),
+      targets: options.targets,
+    });
+    const hasIssues = report.summary.errorCount > 0 || report.summary.warningCount > 0;
+
+    if (options.json) {
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      printHuman(report);
+    }
+
+    process.exitCode = hasIssues ? 1 : 0;
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/ecc.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const { listAvailableLanguages } = require('./lib/install-executor');
+
+const COMMANDS = {
+  install: {
+    script: 'install-apply.js',
+    description: 'Install ECC content into a supported target',
+  },
+  plan: {
+    script: 'install-plan.js',
+    description: 'Inspect selective-install manifests and resolved plans',
+  },
+  'install-plan': {
+    script: 'install-plan.js',
+    description: 'Alias for plan',
+  },
+  'list-installed': {
+    script: 'list-installed.js',
+    description: 'Inspect install-state files for the current context',
+  },
+  doctor: {
+    script: 'doctor.js',
+    description: 'Diagnose missing or drifted ECC-managed files',
+  },
+  repair: {
+    script: 'repair.js',
+    description: 'Restore drifted or missing ECC-managed files',
+  },
+  status: {
+    script: 'status.js',
+    description: 'Query the ECC SQLite state store status summary',
+  },
+  sessions: {
+    script: 'sessions-cli.js',
+    description: 'List or inspect ECC sessions from the SQLite state store',
+  },
+  'session-inspect': {
+    script: 'session-inspect.js',
+    description: 'Emit canonical ECC session snapshots from dmux or Claude history targets',
+  },
+  uninstall: {
+    script: 'uninstall.js',
+    description: 'Remove ECC-managed files recorded in install-state',
+  },
+};
+
+const PRIMARY_COMMANDS = [
+  'install',
+  'plan',
+  'list-installed',
+  'doctor',
+  'repair',
+  'status',
+  'sessions',
+  'session-inspect',
+  'uninstall',
+];
+
+function showHelp(exitCode = 0) {
+  console.log(`
+ECC selective-install CLI
+
+Usage:
+  ecc <command> [args...]
+  ecc [install args...]
+
+Commands:
+${PRIMARY_COMMANDS.map(command => `  ${command.padEnd(15)} ${COMMANDS[command].description}`).join('\n')}
+
+Compatibility:
+  ecc-install        Legacy install entrypoint retained for existing flows
+  ecc [args...]      Without a command, args are routed to "install"
+  ecc help <command> Show help for a specific command
+
+Examples:
+  ecc typescript
+  ecc install --profile developer --target claude
+  ecc plan --profile core --target cursor
+  ecc list-installed --json
+  ecc doctor --target cursor
+  ecc repair --dry-run
+  ecc status --json
+  ecc sessions
+  ecc sessions session-active --json
+  ecc session-inspect claude:latest
+  ecc uninstall --target antigravity --dry-run
+`);
+
+  process.exit(exitCode);
+}
+
+function resolveCommand(argv) {
+  const args = argv.slice(2);
+
+  if (args.length === 0) {
+    return { mode: 'help' };
+  }
+
+  const [firstArg, ...restArgs] = args;
+
+  if (firstArg === '--help' || firstArg === '-h') {
+    return { mode: 'help' };
+  }
+
+  if (firstArg === 'help') {
+    return {
+      mode: 'help-command',
+      command: restArgs[0] || null,
+    };
+  }
+
+  if (COMMANDS[firstArg]) {
+    return {
+      mode: 'command',
+      command: firstArg,
+      args: restArgs,
+    };
+  }
+
+  const knownLegacyLanguages = listAvailableLanguages();
+  const shouldTreatAsImplicitInstall = (
+    firstArg.startsWith('-')
+    || knownLegacyLanguages.includes(firstArg)
+  );
+
+  if (!shouldTreatAsImplicitInstall) {
+    throw new Error(`Unknown command: ${firstArg}`);
+  }
+
+  return {
+    mode: 'command',
+    command: 'install',
+    args,
+  };
+}
+
+function runCommand(commandName, args) {
+  const command = COMMANDS[commandName];
+  if (!command) {
+    throw new Error(`Unknown command: ${commandName}`);
+  }
+
+  const result = spawnSync(
+    process.execPath,
+    [path.join(__dirname, command.script), ...args],
+    {
+      cwd: process.cwd(),
+      env: process.env,
+      encoding: 'utf8',
+      maxBuffer: 10 * 1024 * 1024,
+    }
+  );
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.stdout) {
+    process.stdout.write(result.stdout);
+  }
+
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+
+  if (typeof result.status === 'number') {
+    return result.status;
+  }
+
+  if (result.signal) {
+    throw new Error(`Command "${commandName}" terminated by signal ${result.signal}`);
+  }
+
+  return 1;
+}
+
+function main() {
+  try {
+    const resolution = resolveCommand(process.argv);
+
+    if (resolution.mode === 'help') {
+      showHelp(0);
+    }
+
+    if (resolution.mode === 'help-command') {
+      if (!resolution.command) {
+        showHelp(0);
+      }
+
+      if (!COMMANDS[resolution.command]) {
+        throw new Error(`Unknown command: ${resolution.command}`);
+      }
+
+      process.exitCode = runCommand(resolution.command, ['--help']);
+      return;
+    }
+
+    process.exitCode = runCommand(resolution.command, resolution.args);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/generate-aw-hooks.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Unified AW hook generator.
+ *
+ * Usage:
+ *   node scripts/generate-aw-hooks.js            # generate all harnesses
+ *   node scripts/generate-aw-hooks.js claude     # generate just Claude
+ *   node scripts/generate-aw-hooks.js codex      # generate just Codex
+ *   node scripts/generate-aw-hooks.js cursor     # generate just Cursor
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { getHarnessConfig, getSupportedHarnesses } = require('./lib/aw-harness-registry');
+
+const repoRoot = path.join(__dirname, '..');
+
+/**
+ * Generate hook outputs for a single harness.
+ *
+ * @param {string} harnessName - one of 'claude', 'codex', 'cursor'
+ */
+function generateForHarness(harnessName) {
+  const harness = getHarnessConfig(harnessName);
+
+  const homeSourceDir = path.join(repoRoot, harness.getHomeSourceDir());
+  fs.mkdirSync(homeSourceDir, { recursive: true });
+
+  // Copy non-shared hook files from their canonical source to the output dir.
+  if (harness.hookFiles.length > 0) {
+    const sourceDir = path.join(repoRoot, harness.getHookSourceDir());
+    const outputDir = path.join(repoRoot, harness.getOutputDir());
+    fs.mkdirSync(outputDir, { recursive: true });
+
+    for (const fileName of harness.hookFiles) {
+      const sourcePath = path.join(sourceDir, fileName);
+      const destinationPath = path.join(outputDir, fileName);
+      const content = fs.readFileSync(sourcePath, 'utf8');
+      fs.writeFileSync(destinationPath, content);
+      if (path.extname(fileName) === '.sh') {
+        fs.chmodSync(destinationPath, 0o755);
+      }
+    }
+  }
+
+  // Copy shared hook files (e.g. cursor shared/).
+  if (harness.sharedHookFiles && harness.sharedHookFiles.length > 0) {
+    const sharedSourceDir = path.join(repoRoot, harness.getSharedHookSourceDir());
+    const outputSharedDir = path.join(repoRoot, harness.getOutputSharedDir());
+    fs.mkdirSync(outputSharedDir, { recursive: true });
+
+    for (const fileName of harness.sharedHookFiles) {
+      const sourcePath = path.join(sharedSourceDir, fileName);
+      const destinationPath = path.join(outputSharedDir, fileName);
+      const content = fs.readFileSync(sourcePath, 'utf8');
+      fs.writeFileSync(destinationPath, content);
+    }
+  }
+
+  // Serialize and write the hooks.json config.
+  const hooksJson = harness.serialize(repoRoot);
+
+  // Write to the harness home source dir (used as neutral source).
+  const homeSourceHooksJsonPath = path.join(homeSourceDir, 'hooks.json');
+  fs.writeFileSync(homeSourceHooksJsonPath, hooksJson);
+
+  // Write to the harness runtime output location.
+  const outputHooksJsonPath = getOutputHooksJsonPath(harness);
+  if (outputHooksJsonPath) {
+    fs.mkdirSync(path.dirname(outputHooksJsonPath), { recursive: true });
+    fs.writeFileSync(outputHooksJsonPath, hooksJson);
+  }
+}
+
+/**
+ * Returns the runtime output path for hooks.json for the given harness.
+ * Returns null if the harness does not have a separate runtime output.
+ *
+ * @param {object} harness
+ * @returns {string|null}
+ */
+function getOutputHooksJsonPath(harness) {
+  switch (harness.name) {
+    case 'claude':
+      return path.join(repoRoot, 'hooks', 'hooks.json');
+    case 'codex':
+      return path.join(repoRoot, '.codex', 'hooks.json');
+    case 'cursor':
+      return path.join(repoRoot, '.cursor', 'hooks.json');
+    default:
+      return null;
+  }
+}
+
+function main() {
+  const requestedHarness = process.argv[2];
+  const harnesses = requestedHarness ? [requestedHarness] : getSupportedHarnesses();
+
+  // Validate before generating so we fail fast on typos.
+  for (const h of harnesses) {
+    getHarnessConfig(h); // throws on unknown harness
+  }
+
+  for (const h of harnesses) {
+    generateForHarness(h);
+  }
+}
+
+main();