@sallmarta/eye-hate-agent 1.0.2 → 1.0.4

package/src/engine/install.js

@@ -1,222 +1,124 @@
 const fs = require('node:fs');
 const path = require('node:path');
+const { version: EHA_PACKAGE_VERSION } = require('../../package.json');
 
-const { listWorkflows, getWorkflow } = require('./workflow-registry');
-const { getRuntimeAdapter, listSupportedRuntimes } = require('./runtime-adapters');
+const { listWorkflows } = require('./workflow-registry');
+const { listSkills } = require('./skill-registry');
+const { getRuntimeAdapter, listSupportedRuntimes, SUPPORTED_AGENT_IDS } = require('./runtime-adapters');
 const {
   ensureDir,
   getBundledAssetPath,
   getEnginePaths,
+  readConfig,
   readJsonIfExists,
   removeEmptyParents,
   removeFileIfExists,
+  writeConfig,
   writeJson,
   writeText,
 } = require('./state');
 
-const DEFAULT_RUNTIME_IDS = ['claude', 'copilot'];
-const BUNDLED_CONTRACT_PATH = path.join('docs', 'eyehateagent-contract.md');
-
-function resolveRuntimeIds(runtimes) {
-  const runtimeIds = runtimes && runtimes.length > 0 ? runtimes : DEFAULT_RUNTIME_IDS;
-  return [...new Set(runtimeIds.map((runtime) => String(runtime).trim().toLowerCase()).filter(Boolean))];
+function resolveAgentId(agentId) {
+  const normalized = String(agentId || '').trim().toLowerCase();
+  if (!SUPPORTED_AGENT_IDS.includes(normalized)) {
+    throw new Error(`Unsupported agent: ${agentId}. Choose one of: ${SUPPORTED_AGENT_IDS.join(', ')}.`);
+  }
+  return normalized;
 }
 
 function readManifest(manifestPath) {
   return (
     readJsonIfExists(manifestPath) || {
-      generatedOutputsInsideRepo: true,
       manifestVersion: 1,
-      runtimes: {},
+      agent: null,
+      files: [],
     }
   );
 }
 
-function buildManifestSummary(runtimeId, adapter, files) {
-  return {
-    files: files.map((file) => file.relativePath),
-    supportTier: adapter.supportTier,
-    updatedAt: new Date().toISOString(),
-  };
-}
-
-function getGeneratedSourceRelativePath(repoRelativePath) {
-  return path.join('.eha', 'generated', 'sources', repoRelativePath);
-}
-
-function materializeBundledSources(rootDir, workflows) {
-  const repoRelativePaths = new Set([BUNDLED_CONTRACT_PATH]);
-  for (const workflow of workflows) {
-    repoRelativePaths.add(workflow.repoRelativePath);
-  }
-
-  const generatedSourcePaths = {};
-
-  for (const repoRelativePath of repoRelativePaths) {
-    const sourcePath = getBundledAssetPath(repoRelativePath);
-    const targetRelativePath = getGeneratedSourceRelativePath(repoRelativePath);
-    const targetPath = path.join(rootDir, targetRelativePath);
-    writeText(targetPath, fs.readFileSync(sourcePath, 'utf8'));
-    generatedSourcePaths[repoRelativePath] = targetRelativePath;
-  }
-
-  return {
-    contractPath: generatedSourcePaths[BUNDLED_CONTRACT_PATH],
-    workflowPaths: generatedSourcePaths,
-  };
-}
-
-function installRuntimes({ rootDir, runtimes }) {
-  const runtimeIds = resolveRuntimeIds(runtimes);
-  const enginePaths = getEnginePaths(rootDir);
-  const manifest = readManifest(enginePaths.manifestPath);
+function initProject({ rootDir, agentId }) {
+  const normalizedAgentId = resolveAgentId(agentId);
+  const adapter = getRuntimeAdapter(normalizedAgentId);
   const workflows = listWorkflows();
-  const bundledSources = materializeBundledSources(rootDir, workflows);
-  const runtimeSummaries = [];
-
-  for (const runtimeId of runtimeIds) {
-    const adapter = getRuntimeAdapter(runtimeId);
-    const files = adapter.generateFiles(rootDir, workflows, bundledSources);
+  const skills = listSkills();
+  const files = adapter.generateFiles(rootDir, workflows, skills);
 
-    for (const file of files) {
-      const absolutePath = path.join(rootDir, file.relativePath);
-      ensureDir(path.dirname(absolutePath));
-      writeText(absolutePath, file.content);
-    }
-
-    manifest.runtimes[runtimeId] = buildManifestSummary(runtimeId, adapter, files);
-    runtimeSummaries.push({
-      id: runtimeId,
-      supportTier: adapter.supportTier,
-      fileCount: files.length,
-    });
+  for (const file of files) {
+    const absolutePath = path.join(rootDir, file.relativePath);
+    ensureDir(path.dirname(absolutePath));
+    writeText(absolutePath, file.content);
   }
 
+  const enginePaths = getEnginePaths(rootDir);
+  const manifest = {
+    manifestVersion: 1,
+    agent: normalizedAgentId,
+    files: files.map((f) => f.relativePath),
+    updatedAt: new Date().toISOString(),
+    packageVersion: EHA_PACKAGE_VERSION,
+  };
   writeJson(enginePaths.manifestPath, manifest);
+  const config = writeConfig(rootDir, { agent: normalizedAgentId });
 
   return {
     rootDir,
-    runtimes: runtimeIds,
-    manifestPath: enginePaths.manifestPath,
-    runtimeSummaries,
+    agentId: normalizedAgentId,
+    config,
+    files: manifest.files,
+    fileCount: files.length,
   };
 }
 
-function uninstallRuntimes({ rootDir, runtimes }) {
+function removeProject({ rootDir }) {
   const enginePaths = getEnginePaths(rootDir);
   const manifest = readManifest(enginePaths.manifestPath);
-  const runtimeIds = resolveRuntimeIds(runtimes);
-  const runtimeSummaries = [];
-
-  for (const runtimeId of runtimeIds) {
-    const manifestEntry = manifest.runtimes[runtimeId];
-    if (!manifestEntry) {
-      runtimeSummaries.push({ id: runtimeId, supportTier: 'unknown', fileCount: 0 });
-      continue;
-    }
+  const removedFiles = [];
 
-    for (const relativePath of manifestEntry.files) {
-      const absolutePath = path.join(rootDir, relativePath);
-      removeFileIfExists(absolutePath);
-      removeEmptyParents(path.dirname(absolutePath), rootDir);
-    }
-
-    runtimeSummaries.push({
-      id: runtimeId,
-      supportTier: manifestEntry.supportTier,
-      fileCount: manifestEntry.files.length,
-    });
-    delete manifest.runtimes[runtimeId];
-  }
-
-  if (Object.keys(manifest.runtimes).length === 0) {
-    removeFileIfExists(enginePaths.manifestPath);
-    removeEmptyParents(path.dirname(enginePaths.manifestPath), rootDir);
-  } else {
-    writeJson(enginePaths.manifestPath, manifest);
-  }
-
-  return {
-    rootDir,
-    runtimes: runtimeIds,
-    manifestPath: enginePaths.manifestPath,
-    runtimeSummaries,
-  };
-}
-
-function buildPromptContent(workflow, sourcePaths, contextText, invokedAs) {
-  const commandLabel = invokedAs || workflow.commandName;
-
-  let content = `# EHA Workflow Dispatch\n\n`;
-  content += `Read \`${sourcePaths.contractPath}\` first.\n\n`;
-  content += `Execute \`${sourcePaths.workflowPath}\`.\n\n`;
-  content += `Requested via CLI command: \`${commandLabel}\`\n`;
-
-  if (workflow.capabilityNote) {
-    content += `\n> Note: ${workflow.capabilityNote}\n`;
+  for (const relativePath of manifest.files || []) {
+    const absolutePath = path.join(rootDir, relativePath);
+    removeFileIfExists(absolutePath);
+    removeEmptyParents(path.dirname(absolutePath), rootDir);
+    removedFiles.push(relativePath);
   }
 
-  if (contextText) {
-    content += `\n## Additional CLI Context\n\n${contextText}\n`;
-  }
+  removeFileIfExists(enginePaths.manifestPath);
+  removeEmptyParents(path.dirname(enginePaths.manifestPath), rootDir);
+  removeFileIfExists(enginePaths.configPath);
+  removeEmptyParents(path.dirname(enginePaths.configPath), rootDir);
 
-  return content;
-}
-
-function prepareWorkflowRun({ rootDir, workflowId, contextText = '', invokedAs = null }) {
-  const workflow = getWorkflow(workflowId);
-  const enginePaths = getEnginePaths(rootDir);
-  const bundledSources = materializeBundledSources(rootDir, [workflow]);
-  const promptContent = buildPromptContent(
-    workflow,
-    {
-      contractPath: bundledSources.contractPath,
-      workflowPath: bundledSources.workflowPaths[workflow.repoRelativePath],
-    },
-    contextText,
-    invokedAs,
-  );
-
-  writeText(enginePaths.lastPromptPath, promptContent);
-  writeJson(enginePaths.lastRunPath, {
-    workflowId: workflow.id,
-    invokedAs: invokedAs || workflow.commandName,
-    promptPath: path.relative(rootDir, enginePaths.lastPromptPath),
-    sourceWorkflowPath: workflow.repoRelativePath,
-    contextText,
-    updatedAt: new Date().toISOString(),
-  });
-
-  return {
-    workflow,
-    promptContent,
-    promptPath: path.relative(rootDir, enginePaths.lastPromptPath),
-    contextText,
-  };
+  return { rootDir, removedFiles };
 }
 
 function doctor({ rootDir }) {
   const enginePaths = getEnginePaths(rootDir);
   const manifest = readManifest(enginePaths.manifestPath);
-  const installedRuntimes = Object.entries(manifest.runtimes).map(([id, entry]) => ({
-    id,
-    supportTier: entry.supportTier,
-    fileCount: entry.files.length,
+  const config = readConfig(rootDir);
+
+  const generatedFiles = (manifest.files || []).map((relativePath) => ({
+    relativePath,
+    exists: fs.existsSync(path.join(rootDir, relativePath)),
   }));
 
   return {
     rootDir,
-    generatedOutputsInsideRepo: true,
+    config,
+    agentId: config.agent,
     paths: enginePaths,
-    supportedRuntimes: listSupportedRuntimes(),
-    installedRuntimes,
+    supportedAgents: listSupportedRuntimes(),
+    generatedFiles,
+    isInitialized: Boolean(config.agent),
   };
 }
 
+function readProjectManifest(rootDir) {
+  const { manifestPath } = getEnginePaths(rootDir);
+  return readManifest(manifestPath);
+}
+
 module.exports = {
-  DEFAULT_RUNTIME_IDS,
+  SUPPORTED_AGENT_IDS,
   doctor,
-  installRuntimes,
-  prepareWorkflowRun,
-  uninstallRuntimes,
+  initProject,
+  readProjectManifest,
+  removeProject,
 };

package/src/engine/runtime-adapters.js

@@ -1,106 +1,322 @@
+'use strict';
+
+const fs = require('node:fs');
 const path = require('node:path');
 
-function renderClaudeCommand(workflow, sourcePaths) {
+const { getBundledAssetPath } = require('./state');
+
+const SUPPORTED_AGENT_IDS = ['claude', 'copilot', 'antigravity'];
+
+// Compact EHA rules embedded in every generated command file so the agent
+// has all structural context without needing any external file reference.
+const EHA_COMPACT_RULES = `## EHA Project Doc Rules
+
+**4-Layer Taxonomy.** All project docs live under \`docs/project-docs/\`:
+- \`foundation/\` — prd, architecture, workflow, status, phases, changelog, feature-inventory
+- \`operations/\` — ci-cd, production-runbook, governance, compliance, observability, security
+- \`development/\` — testing, api-contract, database, ui-ux, error-handling, internationalization
+- \`technical-guidelines/\` — domain-specific cross-cutting rules (API, database, logging, etc.)
+
+**Legacy/Reference Docs:** Treat folders named \`archive/\`, \`docs-legacy/\`, or \`reference/\` as secondary migration input only, never as authoritative active truth.
+
+**Mandatory core docs:** \`index.md\`, \`getting-started.md\`, \`foundation/prd.md\`, \`foundation/architecture.md\`, \`foundation/workflow.md\`, \`foundation/status.md\`, \`foundation/phases.md\`, \`operations/ci-cd.md\`, \`operations/production-runbook.md\`, \`development/testing.md\`, \`development/api-contract.md\`, \`development/database.md\`, \`development/ui-ux.md\`.
+
+**Authority order:** project docs → codebase → agent judgment. When docs conflict, the owning doc wins. When code and docs conflict and authority is unclear, surface the conflict and ask the user — do not guess.
+
+**Universal stable headings (every file):** Description, Important, Table of Contents, Scope, Goals, Non Goals.
+
+**Key ownership rules:**
+- Vision, personas, requirements → \`foundation/prd.md\`
+- Stack and architecture → \`foundation/architecture.md\`
+- Dev loop and PR process → \`foundation/workflow.md\`
+- Verification commands and quality gates → \`development/testing.md\`
+- Execution plan and progress → \`foundation/status.md\`
+- Sprint tracking and backlogs → \`foundation/phases.md\`
+- Optional doc inventory → \`index.md\`
+- Domain-specific technical rules → \`technical-guidelines/\` (Create these only for durable cross-cutting rules; avoid placeholders).
+
+**SDD rule:** Specifications dictate implementation. Follow a strict 4-step workflow: 1. Update project docs first, 2. Generate tests based on the specs, 3. Generate code to pass the tests, 4. Logically map every code change back to a spec requirement. Refuse to write code for features not in the spec.
+
+**Flexible Baselines Principle:** Omit docs the repo doesn't need. Mark unknowns as \`TBD\` or \`Assumption\`. Mark inferred facts as \`Inferred from codebase\` until the user confirms them.`;
+
+function loadPromptContent(workflow) {
+  const promptPath = getBundledAssetPath(workflow.repoRelativePath);
+  const raw = fs.readFileSync(promptPath, 'utf8');
+  // Remove the "Read `docs/eyehateagent-contract.md` first." line — the
+  // compact rules block replaces that dependency.
+  return raw
+    .split('\n')
+    .filter((line) => !line.includes('docs/eyehateagent-contract.md'))
+    .join('\n')
+    .replace(/^\n+/, '');
+}
+
+function loadSkillContent(skill) {
+  const promptPath = getBundledAssetPath(skill.repoRelativePath);
+  const raw = fs.readFileSync(promptPath, 'utf8');
+  const parts = raw.split(/^---\r?\n/m);
+  let body = parts.length > 2 ? parts.slice(2).join('---\n') : raw;
+  return body
+    .split('\n')
+    .filter((line) => !line.includes('docs/eyehateagent-contract.md'))
+    .join('\n')
+    .replace(/^\n+/, '');
+}
+
+function loadRuleContent(agentId) {
+  const rulePath = getBundledAssetPath(path.join('docs', 'templates', 'rules', 'agent-rules.md'));
+  let content = fs.readFileSync(rulePath, 'utf8').replace(/^\n+/, '');
+  
+  if (agentId) {
+    const agentsToFilter = SUPPORTED_AGENT_IDS.filter(a => a !== agentId.toLowerCase());
+    for (const a of agentsToFilter) {
+      const regex = new RegExp(`^\\s*-\\s*\\*\\*${a}.*$\\n?`, 'gmi');
+      content = content.replace(regex, '');
+    }
+  }
+  
+  return content;
+}
+
+function buildClaudeCommandFile(workflow) {
+  const promptContent = loadPromptContent(workflow);
   return `---
-description: "Run the EHA ${workflow.id} workflow"
+description: "EHA ${workflow.id} — ${workflow.description}"
 ---
 
-Read \`${sourcePaths.contractPath}\` first.
+${EHA_COMPACT_RULES}
 
-Execute \`${sourcePaths.workflowPath}\`.
+---
 
-If the user provides additional context, apply it while preserving the workflow's output contract and the owning-doc rules in \`docs/project-docs/\`.
-`;
+${promptContent}`;
 }
 
-function renderCopilotInstructions(workflows, bundledSources) {
-  const workflowTable = workflows
-    .map(
-      (workflow) =>
-        `- \`${workflow.commandName}\` -> \`${bundledSources.workflowPaths[workflow.repoRelativePath]}\`${workflow.capabilityNote ? ` (${workflow.capabilityNote})` : ''}`,
-    )
-    .join('\n');
+function buildCopilotPromptFile(workflow) {
+  const promptContent = loadPromptContent(workflow);
+  return `---
+mode: agent
+description: "EHA ${workflow.id} — ${workflow.description}"
+---
+
+${EHA_COMPACT_RULES}
+
+---
+
+${promptContent}`;
+}
 
+function buildClaudeSkillFile(skill) {
   return `---
-description: "Generated EHA workflow routing for GitHub Copilot"
+description: "EHA skill — ${skill.commandName}"
+---
+
+${EHA_COMPACT_RULES}
+
+---
+
+${loadSkillContent(skill)}`;
+}
+
+function buildCopilotSkillFile(skill) {
+  return `---
+mode: agent
+description: "EHA skill — ${skill.commandName}"
+---
+
+${EHA_COMPACT_RULES}
+
+---
+
+${loadSkillContent(skill)}`;
+}
+
+function buildClaudeRuleFile() {
+  return `---
+description: "EHA agent rules"
+---
+
+${loadRuleContent('claude')}`;
+}
+
+function buildCopilotRuleFile() {
+  return `---
+description: "EHA agent rules"
 applyTo: "**"
 ---
 
-# EHA Engine Workflows
+${loadRuleContent('copilot')}`;
+}
 
-When a user asks to run an EHA workflow, prefer the canonical reusable prompt file listed below and preserve its output contract.
+function buildAntigravityCommandFile(workflow) {
+  const promptContent = loadPromptContent(workflow);
+  return `---
+name: "eha-${workflow.commandName}"
+description: "EHA ${workflow.id} — ${workflow.description}"
+---
 
-${workflowTable}
+${EHA_COMPACT_RULES}
 
-## Runtime support
+---
 
-- GitHub Copilot support tier is **guided**
-- this install generates repo-local instructions, not slash commands
-- bundled contract path: \`${bundledSources.contractPath}\`
-- generated outputs stay inside the repository for transparency
-`;
+${promptContent}`;
+}
+
+function buildAntigravitySkillFile(skill) {
+  return `---
+name: "eha-${skill.commandName}"
+description: "EHA skill — ${skill.commandName}"
+---
+
+${EHA_COMPACT_RULES}
+
+---
+
+${loadSkillContent(skill)}`;
+}
+
+function buildAntigravityRuleFile() {
+  return `---
+name: "eha-agent-rules"
+description: "EHA agent rules"
+---
+
+${loadRuleContent('antigravity')}`;
+}
+
+function buildCopilotInstructionsFile(workflows) {
+  const workflowTable = workflows
+    .map((w) => `- \`${w.commandName}\` → \`.github/prompts/eha-${w.commandName}.prompt.md\``)
+    .join('\n');
+
+  return `---
+description: "EHA workflow routing for GitHub Copilot"
+applyTo: "**"
+---
+
+# EHA Workflows
+
+When a user asks to run an EHA workflow, use the matching prompt file below.
+
+${workflowTable}`;
 }
 
 const RUNTIME_ADAPTERS = {
   claude: {
     id: 'claude',
     name: 'Claude',
-    supportTier: 'full',
-    description: 'Repo-local Claude command projection under .claude/commands/eha/',
-    generateFiles(rootDir, workflows, bundledSources) {
+    description: 'Generates .claude/commands/eha/ slash command files, .claude/skills/ and .claude/rules/',
+    generateFiles(rootDir, workflows, skills) {
       const files = [];
       for (const workflow of workflows) {
         files.push({
           relativePath: path.join('.claude', 'commands', 'eha', `eha-${workflow.commandName}.md`),
-          content: renderClaudeCommand(workflow, {
-            contractPath: bundledSources.contractPath,
-            workflowPath: bundledSources.workflowPaths[workflow.repoRelativePath],
-          }),
+          content: buildClaudeCommandFile(workflow),
         });
       }
-
       files.push({
         relativePath: path.join('.claude', 'commands', 'eha', 'README.md'),
-        content:
-          '# Generated EHA Claude commands\n\nThese files are generated by `eha install` from the canonical workflow registry.\n',
+        content: `# EHA Claude commands\n\nGenerated by \`eha init\`. Use \`/eha-bootstrap\`, \`/eha-refresh\`, \`/eha-parity\`, or \`/eha-discuss\` in Claude.\n`,
       });
-
+      
+      for (const skill of skills) {
+        files.push({
+          relativePath: path.join('.claude', 'skills', `eha-${skill.commandName}.md`),
+          content: buildClaudeSkillFile(skill),
+        });
+      }
+      
+      files.push({
+        relativePath: path.join('.claude', 'rules', 'eha-agent-rules.md'),
+        content: buildClaudeRuleFile(),
+      });
+      
       return files;
     },
   },
   copilot: {
     id: 'copilot',
     name: 'GitHub Copilot',
-    supportTier: 'guided',
-    description: 'Repo-local Copilot instruction projection under .github/instructions/',
-    generateFiles(rootDir, workflows, bundledSources) {
-      return [
-        {
-          relativePath: path.join('.github', 'instructions', 'eha-workflows.instructions.md'),
-          content: renderCopilotInstructions(workflows, bundledSources),
-        },
-      ];
+    description: 'Generates .github/prompts/ reusable prompt files, skills, and always-on instruction rules',
+    generateFiles(rootDir, workflows, skills) {
+      const files = [];
+      for (const workflow of workflows) {
+        files.push({
+          relativePath: path.join('.github', 'prompts', `eha-${workflow.commandName}.prompt.md`),
+          content: buildCopilotPromptFile(workflow),
+        });
+      }
+      files.push({
+        relativePath: path.join('.github', 'instructions', 'eha-workflows.instructions.md'),
+        content: buildCopilotInstructionsFile(workflows),
+      });
+      
+      for (const skill of skills) {
+        files.push({
+          relativePath: path.join('.github', 'prompts', 'skills', `eha-${skill.commandName}.prompt.md`),
+          content: buildCopilotSkillFile(skill),
+        });
+      }
+      
+      files.push({
+        relativePath: path.join('.github', 'instructions', 'eha-agent-rules.instructions.md'),
+        content: buildCopilotRuleFile(),
+      });
+      
+      return files;
+    },
+  },
+  antigravity: {
+    id: 'antigravity',
+    name: 'Antigravity',
+    description: 'Generates Antigravity-compatible skills in .agents/skills/',
+    generateFiles(rootDir, workflows, skills) {
+      const files = [];
+      for (const workflow of workflows) {
+        files.push({
+          relativePath: path.join('.agents', 'skills', `eha-${workflow.commandName}`, 'SKILL.md'),
+          content: buildAntigravityCommandFile(workflow),
+        });
+      }
+      files.push({
+        relativePath: path.join('.agents', 'commands', 'eha', 'README.md'),
+        content: `# EHA Antigravity commands\n\nGenerated by \`eha init\`. Call the generated skills directly.\n`,
+      });
+      
+      for (const skill of skills) {
+        files.push({
+          relativePath: path.join('.agents', 'skills', `eha-${skill.commandName}`, 'SKILL.md'),
+          content: buildAntigravitySkillFile(skill),
+        });
+      }
+      
+      files.push({
+        relativePath: path.join('.agents', 'skills', 'eha-agent-rules', 'SKILL.md'),
+        content: buildAntigravityRuleFile(),
+      });
+      
+      return files;
     },
   },
 };
 
-function getRuntimeAdapter(runtimeId) {
-  const adapter = RUNTIME_ADAPTERS[String(runtimeId).trim().toLowerCase()];
+function getRuntimeAdapter(agentId) {
+  const adapter = RUNTIME_ADAPTERS[String(agentId).trim().toLowerCase()];
   if (!adapter) {
-    throw new Error(`Unsupported runtime: ${runtimeId}`);
+    throw new Error(`Unsupported agent: ${agentId}. Choose one of: ${Object.keys(RUNTIME_ADAPTERS).join(', ')}.`);
   }
   return adapter;
 }
 
 function listSupportedRuntimes() {
-  return Object.values(RUNTIME_ADAPTERS).map((runtime) => ({
-    id: runtime.id,
-    supportTier: runtime.supportTier,
-    description: runtime.description,
+  return Object.values(RUNTIME_ADAPTERS).map((a) => ({
+    id: a.id,
+    name: a.name,
+    description: a.description,
   }));
 }
 
 module.exports = {
   getRuntimeAdapter,
   listSupportedRuntimes,
+  SUPPORTED_AGENT_IDS,
 };