kodelyth-ecc 1.2.0

package/scripts/hooks/stop-format-typecheck.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+/**
+ * Stop Hook: Batch format and typecheck all JS/TS files edited this response
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Reads the accumulator written by post-edit-accumulator.js and processes all
+ * edited files in one pass: groups files by project root for a single formatter
+ * invocation per root, and groups .ts/.tsx files by tsconfig dir for a single
+ * tsc --noEmit per tsconfig. The accumulator is cleared on read so repeated
+ * Stop calls do not double-process files.
+ *
+ * Per-batch timeout is proportional to the number of batches so the total
+ * never exceeds the Stop hook budget (90 s reserved for overhead).
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const { execFileSync, spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { findProjectRoot, detectFormatter, resolveFormatterBin } = require('../lib/resolve-formatter');
+
+const MAX_STDIN = 1024 * 1024;
+// Total ms budget reserved for all batches (leaves headroom below the 300s Stop timeout)
+const TOTAL_BUDGET_MS = 270_000;
+
+// Characters cmd.exe treats as separators/operators when shell: true is used.
+// Includes spaces and parentheses to guard paths like "C:\Users\John Doe\...".
+const UNSAFE_PATH_CHARS = /[&|<>^%!\s()]/;
+
+/** Parse the accumulator text into a deduplicated array of file paths. */
+function parseAccumulator(raw) {
+  return [...new Set(raw.split('\n').map(l => l.trim()).filter(Boolean))];
+}
+
+function getAccumFile() {
+  const raw =
+    process.env.CLAUDE_SESSION_ID ||
+    crypto.createHash('sha1').update(process.cwd()).digest('hex').slice(0, 12);
+  const sessionId = raw.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+  return path.join(os.tmpdir(), `ecc-edited-${sessionId}.txt`);
+}
+
+function formatBatch(projectRoot, files, timeoutMs) {
+  const formatter = detectFormatter(projectRoot);
+  if (!formatter) return;
+
+  const resolved = resolveFormatterBin(projectRoot, formatter);
+  if (!resolved) return;
+
+  const existingFiles = files.filter(f => fs.existsSync(f));
+  if (existingFiles.length === 0) return;
+
+  const fileArgs =
+    formatter === 'biome'
+      ? [...resolved.prefix, 'check', '--write', ...existingFiles]
+      : [...resolved.prefix, '--write', ...existingFiles];
+
+  try {
+    if (process.platform === 'win32' && resolved.bin.endsWith('.cmd')) {
+      if (existingFiles.some(f => UNSAFE_PATH_CHARS.test(f))) {
+        process.stderr.write('[Hook] stop-format-typecheck: skipping batch — unsafe path chars\n');
+        return;
+      }
+      const result = spawnSync(resolved.bin, fileArgs, { cwd: projectRoot, shell: true, stdio: 'pipe', timeout: timeoutMs });
+      if (result.error) throw result.error;
+    } else {
+      execFileSync(resolved.bin, fileArgs, { cwd: projectRoot, stdio: ['pipe', 'pipe', 'pipe'], timeout: timeoutMs });
+    }
+  } catch {
+    // Formatter not installed or failed — non-blocking
+  }
+}
+
+function findTsConfigDir(filePath) {
+  let dir = path.dirname(filePath);
+  const fsRoot = path.parse(dir).root;
+  let depth = 0;
+  while (dir !== fsRoot && depth < 20) {
+    if (fs.existsSync(path.join(dir, 'tsconfig.json'))) return dir;
+    dir = path.dirname(dir);
+    depth++;
+  }
+  return null;
+}
+
+function typecheckBatch(tsConfigDir, editedFiles, timeoutMs) {
+  const isWin = process.platform === 'win32';
+  const npxBin = isWin ? 'npx.cmd' : 'npx';
+  const args = ['tsc', '--noEmit', '--pretty', 'false'];
+  const opts = { cwd: tsConfigDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: timeoutMs };
+
+  let stdout = '';
+  let stderr = '';
+  let failed = false;
+
+  try {
+    if (isWin) {
+      // .cmd files require shell: true on Windows
+      const result = spawnSync(npxBin, args, { ...opts, shell: true });
+      if (result.error) return; // timed out or not found — non-blocking
+      if (result.status !== 0) {
+        stdout = result.stdout || '';
+        stderr = result.stderr || '';
+        failed = true;
+      }
+    } else {
+      execFileSync(npxBin, args, opts);
+    }
+  } catch (err) {
+    stdout = err.stdout || '';
+    stderr = err.stderr || '';
+    failed = true;
+  }
+
+  if (!failed) return;
+
+  const lines = (stdout + stderr).split('\n');
+  for (const filePath of editedFiles) {
+    const relPath = path.relative(tsConfigDir, filePath);
+    const candidates = new Set([filePath, relPath]);
+    const relevantLines = lines
+      .filter(line => { for (const c of candidates) { if (line.includes(c)) return true; } return false; })
+      .slice(0, 10);
+    if (relevantLines.length > 0) {
+      process.stderr.write(`[Hook] TypeScript errors in ${path.basename(filePath)}:\n`);
+      relevantLines.forEach(line => process.stderr.write(line + '\n'));
+    }
+  }
+}
+
+function main() {
+  const accumFile = getAccumFile();
+
+  let raw;
+  try {
+    raw = fs.readFileSync(accumFile, 'utf8');
+  } catch {
+    return; // No accumulator — nothing edited this response
+  }
+
+  try { fs.unlinkSync(accumFile); } catch { /* best-effort */ }
+
+  const files = parseAccumulator(raw);
+  if (files.length === 0) return;
+
+  const byProjectRoot = new Map();
+  for (const filePath of files) {
+    if (!/\.(ts|tsx|js|jsx)$/.test(filePath)) continue;
+    const resolved = path.resolve(filePath);
+    if (!fs.existsSync(resolved)) continue;
+    const root = findProjectRoot(path.dirname(resolved));
+    if (!byProjectRoot.has(root)) byProjectRoot.set(root, []);
+    byProjectRoot.get(root).push(resolved);
+  }
+
+  const byTsConfigDir = new Map();
+  for (const filePath of files) {
+    if (!/\.(ts|tsx)$/.test(filePath)) continue;
+    const resolved = path.resolve(filePath);
+    if (!fs.existsSync(resolved)) continue;
+    const tsDir = findTsConfigDir(resolved);
+    if (!tsDir) continue;
+    if (!byTsConfigDir.has(tsDir)) byTsConfigDir.set(tsDir, []);
+    byTsConfigDir.get(tsDir).push(resolved);
+  }
+
+  // Distribute the budget evenly across all batches so the cumulative total
+  // stays within the Stop hook wall-clock limit even in large monorepos.
+  const totalBatches = byProjectRoot.size + byTsConfigDir.size;
+  const perBatchMs = totalBatches > 0 ? Math.floor(TOTAL_BUDGET_MS / totalBatches) : 60_000;
+
+  for (const [root, batch] of byProjectRoot) formatBatch(root, batch, perBatchMs);
+  for (const [tsDir, batch] of byTsConfigDir) typecheckBatch(tsDir, batch, perBatchMs);
+}
+
+/**
+ * Exported so run-with-flags.js uses require() instead of spawnSync,
+ * letting the 300s hooks.json timeout govern the full batch.
+ *
+ * @param {string} rawInput - Raw JSON string from stdin (Stop event payload)
+ * @returns {string} The original input (pass-through)
+ */
+function run(rawInput) {
+  try {
+    main();
+  } catch (err) {
+    process.stderr.write(`[Hook] stop-format-typecheck error: ${err.message}\n`);
+  }
+  return rawInput;
+}
+
+if (require.main === module) {
+  let stdinData = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    if (stdinData.length < MAX_STDIN) stdinData += chunk.substring(0, MAX_STDIN - stdinData.length);
+  });
+  process.stdin.on('end', () => {
+    process.stdout.write(run(stdinData));
+    process.exit(0);
+  });
+}
+
+module.exports = { run, parseAccumulator };

package/scripts/hooks/suggest-compact.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * Strategic Compact Suggester
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs on PreToolUse or periodically to suggest manual compaction at logical intervals
+ *
+ * Why manual over auto-compact:
+ * - Auto-compact happens at arbitrary points, often mid-task
+ * - Strategic compacting preserves context through logical phases
+ * - Compact after exploration, before execution
+ * - Compact after completing a milestone, before starting next
+ */
+
+const fs = require('fs');
+const path = require('path');
+const {
+  getTempDir,
+  writeFile,
+  log
+} = require('../lib/utils');
+
+async function main() {
+  // Track tool call count (increment in a temp file)
+  // Use a session-specific counter file based on session ID from environment
+  // or parent PID as fallback
+  const sessionId = (process.env.CLAUDE_SESSION_ID || 'default').replace(/[^a-zA-Z0-9_-]/g, '') || 'default';
+  const counterFile = path.join(getTempDir(), `claude-tool-count-${sessionId}`);
+  const rawThreshold = parseInt(process.env.COMPACT_THRESHOLD || '50', 10);
+  const threshold = Number.isFinite(rawThreshold) && rawThreshold > 0 && rawThreshold <= 10000
+    ? rawThreshold
+    : 50;
+
+  let count = 1;
+
+  // Read existing count or start at 1
+  // Use fd-based read+write to reduce (but not eliminate) race window
+  // between concurrent hook invocations
+  try {
+    const fd = fs.openSync(counterFile, 'a+');
+    try {
+      const buf = Buffer.alloc(64);
+      const bytesRead = fs.readSync(fd, buf, 0, 64, 0);
+      if (bytesRead > 0) {
+        const parsed = parseInt(buf.toString('utf8', 0, bytesRead).trim(), 10);
+        // Clamp to reasonable range — corrupted files could contain huge values
+        // that pass Number.isFinite() (e.g., parseInt('9'.repeat(30)) => 1e+29)
+        count = (Number.isFinite(parsed) && parsed > 0 && parsed <= 1000000)
+          ? parsed + 1
+          : 1;
+      }
+      // Truncate and write new value
+      fs.ftruncateSync(fd, 0);
+      fs.writeSync(fd, String(count), 0);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    // Fallback: just use writeFile if fd operations fail
+    writeFile(counterFile, String(count));
+  }
+
+  // Suggest compact after threshold tool calls
+  if (count === threshold) {
+    log(`[StrategicCompact] ${threshold} tool calls reached - consider /compact if transitioning phases`);
+  }
+
+  // Suggest at regular intervals after threshold (every 25 calls from threshold)
+  if (count > threshold && (count - threshold) % 25 === 0) {
+    log(`[StrategicCompact] ${count} tool calls - good checkpoint for /compact if context is stale`);
+  }
+
+  process.exit(0);
+}
+
+main().catch(err => {
+  console.error('[StrategicCompact] Error:', err.message);
+  process.exit(0);
+});

package/scripts/hooks/test-reminder.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * Kodelyth ECC — Test Reminder Hook
+ * PostToolUse: Edit / Write / MultiEdit
+ *
+ * If code files were edited but NO test file was touched in the same
+ * response, inject a gentle reminder to write tests.
+ *
+ * Respects ECC_DISABLED_HOOKS env var.
+ */
+
+'use strict'
+
+const TEST_FILE_PATTERNS = [
+  /\.(test|spec)\.(ts|tsx|js|jsx|mjs)$/,
+  /\.(test|spec)\.py$/,
+  /__tests__/,
+  /\/tests?\//,
+  /_test\.go$/,
+  /_spec\.rb$/,
+  /\.test\.rs$/,
+  /Test\.java$/,
+  /Spec\.kt$/,
+]
+
+const CODE_FILE_PATTERNS = [
+  /\.(ts|tsx|js|jsx|mjs)$/,
+  /\.py$/,
+  /\.go$/,
+  /\.rs$/,
+  /\.java$/,
+  /\.kt$/,
+  /\.rb$/,
+  /\.cs$/,
+  /\.cpp$|\.cc$|\.cxx$/,
+]
+
+const IGNORED_PATHS = [
+  /node_modules/,
+  /\.git\//,
+  /dist\//,
+  /build\//,
+  /coverage\//,
+  /\.next\//,
+  /\.nuxt\//,
+  /migrations\//,
+  /generated\//,
+]
+
+function isDisabled () {
+  const disabled = (process.env.ECC_DISABLED_HOOKS || '').split(',')
+  return disabled.includes('kodelyth:test-reminder')
+}
+
+function isIgnored (filePath) {
+  return IGNORED_PATHS.some(p => p.test(filePath))
+}
+
+function isTestFile (filePath) {
+  return TEST_FILE_PATTERNS.some(p => p.test(filePath))
+}
+
+function isCodeFile (filePath) {
+  return CODE_FILE_PATTERNS.some(p => p.test(filePath)) && !isTestFile(filePath)
+}
+
+async function main () {
+  if (isDisabled()) {
+    process.stdout.write(await readStdin())
+    return
+  }
+
+  const raw = await readStdin()
+  let input
+
+  try {
+    input = JSON.parse(raw)
+  } catch {
+    process.stdout.write(raw)
+    return
+  }
+
+  // Collect all files touched in this tool use
+  const filePath = input?.tool_input?.file_path || input?.tool_input?.path || ''
+  const files = [filePath].filter(Boolean)
+
+  if (files.length === 0) {
+    process.stdout.write(raw)
+    return
+  }
+
+  const codeFiles = files.filter(f => !isIgnored(f) && isCodeFile(f))
+  const testFiles = files.filter(f => !isIgnored(f) && isTestFile(f))
+
+  // Only remind if code was written but no test file was touched
+  if (codeFiles.length > 0 && testFiles.length === 0) {
+    const fileNames = codeFiles.map(f => f.split('/').pop()).join(', ')
+    const message = [
+      '',
+      '┌─ Kodelyth Test Reminder ───────────────────────────────────┐',
+      `│  Code edited: ${fileNames.slice(0, 50).padEnd(50)} │`,
+      '│  No test file was touched.                                 │',
+      '│                                                            │',
+      '│  Consider: use tdd-guide  or  /tdd                        │',
+      '└────────────────────────────────────────────────────────────┘',
+      '',
+    ].join('\n')
+
+    process.stderr.write(message)
+  }
+
+  process.stdout.write(raw)
+}
+
+function readStdin () {
+  return new Promise((resolve) => {
+    let data = ''
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', chunk => { data += chunk })
+    process.stdin.on('end', () => resolve(data))
+    process.stdin.on('error', () => resolve(data))
+    setTimeout(() => resolve(data), 3000)
+  })
+}
+
+main().catch(() => {
+  process.exit(0) // never block tool execution
+})

package/scripts/install-apply.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * Refactored ECC installer runtime.
+ *
+ * Keeps the legacy language-based install entrypoint intact while moving
+ * target-specific mutation logic into testable Node code.
+ */
+
+const os = require('os');
+const {
+  SUPPORTED_INSTALL_TARGETS,
+  listLegacyCompatibilityLanguages,
+} = require('./lib/install-manifests');
+const {
+  LEGACY_INSTALL_TARGETS,
+  normalizeInstallRequest,
+  parseInstallArgs,
+} = require('./lib/install/request');
+
+function getHelpText() {
+  const languages = listLegacyCompatibilityLanguages();
+
+  return `
+Usage: install.sh [--target <${LEGACY_INSTALL_TARGETS.join('|')}>] [--dry-run] [--json] <language> [<language> ...]
+       install.sh [--target <${SUPPORTED_INSTALL_TARGETS.join('|')}>] [--dry-run] [--json] --profile <name> [--with <component>]... [--without <component>]...
+       install.sh [--target <${SUPPORTED_INSTALL_TARGETS.join('|')}>] [--dry-run] [--json] --modules <id,id,...> [--with <component>]... [--without <component>]...
+       install.sh [--dry-run] [--json] --config <path>
+
+Targets:
+  claude       (default) - Install rules to ~/.claude/rules/
+  cursor       - Install rules, hooks, and bundled Cursor configs to ./.cursor/
+  antigravity  - Install rules, workflows, skills, and agents to ./.agent/
+
+Options:
+  --profile <name>    Resolve and install a manifest profile
+  --modules <ids>     Resolve and install explicit module IDs
+  --with <component>  Include a user-facing install component
+  --without <component>
+                      Exclude a user-facing install component
+  --config <path>     Load install intent from ecc-install.json
+  --dry-run    Show the install plan without copying files
+  --json       Emit machine-readable plan/result JSON
+  --help       Show this help text
+
+Available languages:
+${languages.map(language => `  - ${language}`).join('\n')}
+`;
+}
+
+function showHelp(exitCode = 0) {
+  console.log(getHelpText());
+  process.exit(exitCode);
+}
+
+function printHumanPlan(plan, dryRun) {
+  console.log(`${dryRun ? 'Dry-run install plan' : 'Applying install plan'}:\n`);
+  console.log(`Mode: ${plan.mode}`);
+  console.log(`Target: ${plan.target}`);
+  console.log(`Adapter: ${plan.adapter.id}`);
+  console.log(`Install root: ${plan.installRoot}`);
+  console.log(`Install-state: ${plan.installStatePath}`);
+  if (plan.mode === 'legacy') {
+    console.log(`Languages: ${plan.languages.join(', ')}`);
+  } else {
+    if (plan.mode === 'legacy-compat') {
+      console.log(`Legacy languages: ${plan.legacyLanguages.join(', ')}`);
+    }
+    console.log(`Profile: ${plan.profileId || '(custom modules)'}`);
+    console.log(`Included components: ${plan.includedComponentIds.join(', ') || '(none)'}`);
+    console.log(`Excluded components: ${plan.excludedComponentIds.join(', ') || '(none)'}`);
+    console.log(`Requested modules: ${plan.requestedModuleIds.join(', ') || '(none)'}`);
+    console.log(`Selected modules: ${plan.selectedModuleIds.join(', ') || '(none)'}`);
+    if (plan.skippedModuleIds.length > 0) {
+      console.log(`Skipped modules: ${plan.skippedModuleIds.join(', ')}`);
+    }
+    if (plan.excludedModuleIds.length > 0) {
+      console.log(`Excluded modules: ${plan.excludedModuleIds.join(', ')}`);
+    }
+  }
+  console.log(`Operations: ${plan.operations.length}`);
+
+  if (plan.warnings.length > 0) {
+    console.log('\nWarnings:');
+    for (const warning of plan.warnings) {
+      console.log(`- ${warning}`);
+    }
+  }
+
+  console.log('\nPlanned file operations:');
+  for (const operation of plan.operations) {
+    console.log(`- ${operation.sourceRelativePath} -> ${operation.destinationPath}`);
+  }
+
+  if (!dryRun) {
+    console.log(`\nDone. Install-state written to ${plan.installStatePath}`);
+  }
+}
+
+function main() {
+  try {
+    const options = parseInstallArgs(process.argv);
+
+    if (options.help) {
+      showHelp(0);
+    }
+
+    const {
+      findDefaultInstallConfigPath,
+      loadInstallConfig,
+    } = require('./lib/install/config');
+    const { applyInstallPlan } = require('./lib/install-executor');
+    const { createInstallPlanFromRequest } = require('./lib/install/runtime');
+    const defaultConfigPath = options.configPath || options.languages.length > 0
+      ? null
+      : findDefaultInstallConfigPath({ cwd: process.cwd() });
+    const config = options.configPath
+      ? loadInstallConfig(options.configPath, { cwd: process.cwd() })
+      : (defaultConfigPath ? loadInstallConfig(defaultConfigPath, { cwd: process.cwd() }) : null);
+    const request = normalizeInstallRequest({
+      ...options,
+      config,
+    });
+    const plan = createInstallPlanFromRequest(request, {
+      projectRoot: process.cwd(),
+      homeDir: process.env.HOME || os.homedir(),
+      claudeRulesDir: process.env.CLAUDE_RULES_DIR || null,
+    });
+
+    if (options.dryRun) {
+      if (options.json) {
+        console.log(JSON.stringify({ dryRun: true, plan }, null, 2));
+      } else {
+        printHumanPlan(plan, true);
+      }
+      return;
+    }
+
+    const result = applyInstallPlan(plan);
+    if (options.json) {
+      console.log(JSON.stringify({ dryRun: false, result }, null, 2));
+    } else {
+      printHumanPlan(result, false);
+    }
+  } catch (error) {
+    process.stderr.write(`Error: ${error.message}${getHelpText()}`);
+    process.exit(1);
+  }
+}
+
+main();