aw-ecc 1.4.21

package/scripts/install-apply.js

@@ -0,0 +1,140 @@
+#!/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 {
+  SUPPORTED_INSTALL_TARGETS,
+  listLegacyCompatibilityLanguages,
+} = require('./lib/install-manifests');
+const {
+  LEGACY_INSTALL_TARGETS,
+  normalizeInstallRequest,
+  parseInstallArgs,
+} = require('./lib/install/request');
+
+function showHelp(exitCode = 0) {
+  const languages = listLegacyCompatibilityLanguages();
+
+  console.log(`
+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')}
+`);
+
+  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 { loadInstallConfig } = require('./lib/install/config');
+    const { applyInstallPlan } = require('./lib/install-executor');
+    const { createInstallPlanFromRequest } = require('./lib/install/runtime');
+    const config = options.configPath
+      ? loadInstallConfig(options.configPath, { cwd: process.cwd() })
+      : null;
+    const request = normalizeInstallRequest({
+      ...options,
+      config,
+    });
+    const plan = createInstallPlanFromRequest(request, {
+      projectRoot: process.cwd(),
+      homeDir: process.env.HOME,
+      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) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/install-plan.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * Inspect selective-install profiles and module plans without mutating targets.
+ */
+
+const {
+  listInstallComponents,
+  listInstallModules,
+  listInstallProfiles,
+  resolveInstallPlan,
+} = require('./lib/install-manifests');
+const { loadInstallConfig } = require('./lib/install/config');
+const { normalizeInstallRequest } = require('./lib/install/request');
+
+function showHelp() {
+  console.log(`
+Inspect ECC selective-install manifests
+
+Usage:
+  node scripts/install-plan.js --list-profiles
+  node scripts/install-plan.js --list-modules
+  node scripts/install-plan.js --list-components [--family <family>] [--target <target>] [--json]
+  node scripts/install-plan.js --profile <name> [--with <component>]... [--without <component>]... [--target <target>] [--json]
+  node scripts/install-plan.js --modules <id,id,...> [--with <component>]... [--without <component>]... [--target <target>] [--json]
+  node scripts/install-plan.js --config <path> [--json]
+
+Options:
+  --list-profiles     List available install profiles
+  --list-modules      List install modules
+  --list-components   List user-facing install components
+  --family <family>   Filter listed components by family
+  --profile <name>    Resolve an install profile
+  --modules <ids>     Resolve explicit module IDs (comma-separated)
+  --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
+  --target <target>   Filter plan for a specific target
+  --json              Emit machine-readable JSON
+  --help              Show this help text
+`);
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const parsed = {
+    json: false,
+    help: false,
+    profileId: null,
+    moduleIds: [],
+    includeComponentIds: [],
+    excludeComponentIds: [],
+    configPath: null,
+    target: null,
+    family: null,
+    listProfiles: false,
+    listModules: false,
+    listComponents: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+    } else if (arg === '--json') {
+      parsed.json = true;
+    } else if (arg === '--list-profiles') {
+      parsed.listProfiles = true;
+    } else if (arg === '--list-modules') {
+      parsed.listModules = true;
+    } else if (arg === '--list-components') {
+      parsed.listComponents = true;
+    } else if (arg === '--family') {
+      parsed.family = args[index + 1] || null;
+      index += 1;
+    } else if (arg === '--profile') {
+      parsed.profileId = args[index + 1] || null;
+      index += 1;
+    } else if (arg === '--modules') {
+      const raw = args[index + 1] || '';
+      parsed.moduleIds = raw.split(',').map(value => value.trim()).filter(Boolean);
+      index += 1;
+    } else if (arg === '--with') {
+      const componentId = args[index + 1] || '';
+      if (componentId.trim()) {
+        parsed.includeComponentIds.push(componentId.trim());
+      }
+      index += 1;
+    } else if (arg === '--without') {
+      const componentId = args[index + 1] || '';
+      if (componentId.trim()) {
+        parsed.excludeComponentIds.push(componentId.trim());
+      }
+      index += 1;
+    } else if (arg === '--config') {
+      parsed.configPath = args[index + 1] || null;
+      index += 1;
+    } else if (arg === '--target') {
+      parsed.target = args[index + 1] || null;
+      index += 1;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
+function printProfiles(profiles) {
+  console.log('Install profiles:\n');
+  for (const profile of profiles) {
+    console.log(`- ${profile.id} (${profile.moduleCount} modules)`);
+    console.log(`  ${profile.description}`);
+  }
+}
+
+function printModules(modules) {
+  console.log('Install modules:\n');
+  for (const module of modules) {
+    console.log(`- ${module.id} [${module.kind}]`);
+    console.log(
+      `  targets=${module.targets.join(', ')} default=${module.defaultInstall} cost=${module.cost} stability=${module.stability}`
+    );
+    console.log(`  ${module.description}`);
+  }
+}
+
+function printComponents(components) {
+  console.log('Install components:\n');
+  for (const component of components) {
+    console.log(`- ${component.id} [${component.family}]`);
+    console.log(`  targets=${component.targets.join(', ')} modules=${component.moduleIds.join(', ')}`);
+    console.log(`  ${component.description}`);
+  }
+}
+
+function printPlan(plan) {
+  console.log('Install plan:\n');
+  console.log(
+    'Note: target filtering and operation output currently reflect scaffold-level adapter planning, not a byte-for-byte mirror of legacy install.sh copy paths.\n'
+  );
+  console.log(`Profile: ${plan.profileId || '(custom modules)'}`);
+  console.log(`Target: ${plan.target || '(all targets)'}`);
+  console.log(`Included components: ${plan.includedComponentIds.join(', ') || '(none)'}`);
+  console.log(`Excluded components: ${plan.excludedComponentIds.join(', ') || '(none)'}`);
+  console.log(`Requested: ${plan.requestedModuleIds.join(', ')}`);
+  if (plan.targetAdapterId) {
+    console.log(`Adapter: ${plan.targetAdapterId}`);
+    console.log(`Target root: ${plan.targetRoot}`);
+    console.log(`Install-state: ${plan.installStatePath}`);
+  }
+  console.log('');
+  console.log(`Selected modules (${plan.selectedModuleIds.length}):`);
+  for (const module of plan.selectedModules) {
+    console.log(`- ${module.id} [${module.kind}]`);
+  }
+
+  if (plan.skippedModuleIds.length > 0) {
+    console.log('');
+    console.log(`Skipped for target ${plan.target} (${plan.skippedModuleIds.length}):`);
+    for (const module of plan.skippedModules) {
+      console.log(`- ${module.id} [${module.kind}]`);
+    }
+  }
+
+  if (plan.excludedModuleIds.length > 0) {
+    console.log('');
+    console.log(`Excluded by selection (${plan.excludedModuleIds.length}):`);
+    for (const module of plan.excludedModules) {
+      console.log(`- ${module.id} [${module.kind}]`);
+    }
+  }
+
+  if (plan.operations.length > 0) {
+    console.log('');
+    console.log(`Operation plan (${plan.operations.length}):`);
+    for (const operation of plan.operations) {
+      console.log(
+        `- ${operation.moduleId}: ${operation.sourceRelativePath} -> ${operation.destinationPath} [${operation.strategy}]`
+      );
+    }
+  }
+}
+
+function main() {
+  try {
+    const options = parseArgs(process.argv);
+
+    if (options.help || process.argv.length <= 2) {
+      showHelp();
+      process.exit(0);
+    }
+
+    if (options.listProfiles) {
+      const profiles = listInstallProfiles();
+      if (options.json) {
+        console.log(JSON.stringify({ profiles }, null, 2));
+      } else {
+        printProfiles(profiles);
+      }
+      return;
+    }
+
+    if (options.listModules) {
+      const modules = listInstallModules();
+      if (options.json) {
+        console.log(JSON.stringify({ modules }, null, 2));
+      } else {
+        printModules(modules);
+      }
+      return;
+    }
+
+    if (options.listComponents) {
+      const components = listInstallComponents({
+        family: options.family,
+        target: options.target,
+      });
+      if (options.json) {
+        console.log(JSON.stringify({ components }, null, 2));
+      } else {
+        printComponents(components);
+      }
+      return;
+    }
+
+    const config = options.configPath
+      ? loadInstallConfig(options.configPath, { cwd: process.cwd() })
+      : null;
+    const request = normalizeInstallRequest({
+      ...options,
+      languages: [],
+      config,
+    });
+    const plan = resolveInstallPlan({
+      profileId: request.profileId,
+      moduleIds: request.moduleIds,
+      includeComponentIds: request.includeComponentIds,
+      excludeComponentIds: request.excludeComponentIds,
+      target: request.target,
+    });
+
+    if (options.json) {
+      console.log(JSON.stringify(plan, null, 2));
+    } else {
+      printPlan(plan);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/lib/agent-compress.js

@@ -0,0 +1,244 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse YAML frontmatter from a markdown string.
+ * Returns { frontmatter: {}, body: string }.
+ */
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n([\s\S]*))?$/);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+
+  const frontmatter = {};
+  for (const line of match[1].split('\n')) {
+    const colonIdx = line.indexOf(':');
+    if (colonIdx === -1) continue;
+
+    const key = line.slice(0, colonIdx).trim();
+    let value = line.slice(colonIdx + 1).trim();
+
+    // Handle JSON arrays (e.g. tools: ["Read", "Grep"])
+    if (value.startsWith('[') && value.endsWith(']')) {
+      try {
+        value = JSON.parse(value);
+      } catch {
+        // keep as string
+      }
+    }
+
+    // Strip surrounding quotes
+    if (typeof value === 'string' && value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1);
+    }
+
+    frontmatter[key] = value;
+  }
+
+  return { frontmatter, body: match[2] || '' };
+}
+
+/**
+ * Extract the first meaningful paragraph from agent body as a summary.
+ * Skips headings, list items, code blocks, and table rows.
+ */
+function extractSummary(body, maxSentences = 1) {
+  const lines = body.split('\n');
+  const paragraphs = [];
+  let current = [];
+  let inCodeBlock = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Track fenced code blocks
+    if (trimmed.startsWith('```')) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+
+    if (trimmed === '') {
+      if (current.length > 0) {
+        paragraphs.push(current.join(' '));
+        current = [];
+      }
+      continue;
+    }
+
+    // Skip headings, list items (bold, plain, asterisk), numbered lists, table rows
+    if (
+      trimmed.startsWith('#') ||
+      trimmed.startsWith('- ') ||
+      trimmed.startsWith('* ') ||
+      /^\d+\.\s/.test(trimmed) ||
+      trimmed.startsWith('|')
+    ) {
+      if (current.length > 0) {
+        paragraphs.push(current.join(' '));
+        current = [];
+      }
+      continue;
+    }
+
+    current.push(trimmed);
+  }
+  if (current.length > 0) {
+    paragraphs.push(current.join(' '));
+  }
+
+  const firstParagraph = paragraphs.find(p => p.length > 0);
+  if (!firstParagraph) return '';
+
+  const sentences = firstParagraph.match(/[^.!?]+[.!?]+/g) || [firstParagraph];
+  return sentences.slice(0, maxSentences).map(s => s.trim()).join(' ').trim();
+}
+
+/**
+ * Load and parse a single agent file.
+ */
+function loadAgent(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const { frontmatter, body } = parseFrontmatter(content);
+  const fileName = path.basename(filePath, '.md');
+
+  return {
+    fileName,
+    name: frontmatter.name || fileName,
+    description: frontmatter.description || '',
+    tools: Array.isArray(frontmatter.tools) ? frontmatter.tools : [],
+    model: frontmatter.model || 'sonnet',
+    body,
+    byteSize: Buffer.byteLength(content, 'utf8'),
+  };
+}
+
+/**
+ * Load all agents from a directory.
+ */
+function loadAgents(agentsDir) {
+  if (!fs.existsSync(agentsDir)) return [];
+
+  return fs.readdirSync(agentsDir)
+    .filter(f => f.endsWith('.md'))
+    .sort()
+    .map(f => loadAgent(path.join(agentsDir, f)));
+}
+
+/**
+ * Compress an agent to catalog entry (metadata only).
+ */
+function compressToCatalog(agent) {
+  return {
+    name: agent.name,
+    description: agent.description,
+    tools: agent.tools,
+    model: agent.model,
+  };
+}
+
+/**
+ * Compress an agent to summary entry (metadata + first paragraph).
+ */
+function compressToSummary(agent) {
+  return {
+    ...compressToCatalog(agent),
+    summary: extractSummary(agent.body),
+  };
+}
+
+const allowedModes = ['catalog', 'summary', 'full'];
+
+/**
+ * Build a compressed catalog from a directory of agents.
+ *
+ * Modes:
+ *  - 'catalog': name, description, tools, model only (~2-3k tokens for 27 agents)
+ *  - 'summary': catalog + first paragraph summary (~4-5k tokens)
+ *  - 'full':    no compression, full body included
+ *
+ * Returns { agents: [], stats: { totalAgents, originalBytes, compressedBytes, compressedTokenEstimate, mode } }
+ */
+function buildAgentCatalog(agentsDir, options = {}) {
+  const mode = options.mode || 'catalog';
+
+  if (!allowedModes.includes(mode)) {
+    throw new Error(`Invalid mode "${mode}". Allowed modes: ${allowedModes.join(', ')}`);
+  }
+
+  const filter = options.filter || null;
+
+  let agents = loadAgents(agentsDir);
+
+  if (typeof filter === 'function') {
+    agents = agents.filter(filter);
+  }
+
+  const originalBytes = agents.reduce((sum, a) => sum + a.byteSize, 0);
+
+  let compressed;
+  if (mode === 'catalog') {
+    compressed = agents.map(compressToCatalog);
+  } else if (mode === 'summary') {
+    compressed = agents.map(compressToSummary);
+  } else {
+    compressed = agents.map(a => ({
+      name: a.name,
+      description: a.description,
+      tools: a.tools,
+      model: a.model,
+      body: a.body,
+    }));
+  }
+
+  const compressedJson = JSON.stringify(compressed);
+  // Rough token estimate: ~4 chars per token for English text
+  const compressedTokenEstimate = Math.ceil(compressedJson.length / 4);
+
+  return {
+    agents: compressed,
+    stats: {
+      totalAgents: agents.length,
+      originalBytes,
+      compressedBytes: Buffer.byteLength(compressedJson, 'utf8'),
+      compressedTokenEstimate,
+      mode,
+    },
+  };
+}
+
+/**
+ * Lazy-load a single agent's full content by name.
+ * Returns null if not found.
+ */
+function lazyLoadAgent(agentsDir, agentName) {
+  // Validate agentName: only allow alphanumeric, hyphen, underscore
+  if (!/^[\w-]+$/.test(agentName)) {
+    return null;
+  }
+
+  const filePath = path.resolve(agentsDir, `${agentName}.md`);
+
+  // Verify the resolved path is still within agentsDir
+  const resolvedAgentsDir = path.resolve(agentsDir);
+  if (!filePath.startsWith(resolvedAgentsDir + path.sep)) {
+    return null;
+  }
+
+  if (!fs.existsSync(filePath)) return null;
+  return loadAgent(filePath);
+}
+
+module.exports = {
+  buildAgentCatalog,
+  compressToCatalog,
+  compressToSummary,
+  extractSummary,
+  lazyLoadAgent,
+  loadAgent,
+  loadAgents,
+  parseFrontmatter,
+};