@sallmarta/eye-hate-agent 1.0.2 → 1.0.3

package/docs/templates/skills/operations/observability-setup/SKILL.md

@@ -0,0 +1,13 @@
+# Observability Setup Skill
+
+You are a Site Reliability Engineer (SRE) focused on ensuring deep system observability and alerting.
+
+## Responsibilities
+1. Analyze backend architectures and inject proper structured logging, distributed tracing (e.g., OpenTelemetry), and performance metrics.
+2. Design actionable alerting rules and dashboards for detecting anomalies.
+3. Standardize error handling to ensure contextual data (user IDs, request IDs) is always logged without leaking PII.
+
+## Output Constraints
+- Code modifications should use the project's existing logger (e.g., Winston, Pino) if one exists.
+- Ensure all emitted metrics follow standard naming conventions (e.g., Prometheus format).
+- Never log raw request bodies or unmasked sensitive credentials.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sallmarta/eye-hate-agent",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Template-and-engine toolkit for AI-agent-assisted project workflows.",
   "directories": {
     "doc": "docs"
@@ -8,10 +8,7 @@
   "files": [
     "bin",
     "src",
-    "docs",
-    ".claude",
-    ".github",
-    ".agents",
+    "docs/templates",
     "README.md"
   ],
   "scripts": {
@@ -44,8 +41,9 @@
     "node": ">=18"
   },
   "bin": {
+    "eha": "./bin/eha.js",
     "eye-hate-agent": "./bin/eha.js",
-    "eha": "./bin/eha.js"
+    "eyehateagent": "./bin/eha.js"
   },
   "dependencies": {
     "commander": "^12.0.0",

package/src/engine/index.js

@@ -1,22 +1,17 @@
 const { getWorkflow, listWorkflows } = require('./workflow-registry');
-const { findRepoRoot } = require('./state');
+const { findRepoRoot, readConfig } = require('./state');
 const { listSupportedRuntimes } = require('./runtime-adapters');
-const {
-  DEFAULT_RUNTIME_IDS,
-  doctor,
-  installRuntimes,
-  prepareWorkflowRun,
-  uninstallRuntimes,
-} = require('./install');
+const { SUPPORTED_AGENT_IDS, doctor, initProject, readProjectManifest, removeProject } = require('./install');
 
 module.exports = {
-  DEFAULT_RUNTIME_IDS,
+  SUPPORTED_AGENT_IDS,
   doctor,
   findRepoRoot,
   getWorkflow,
-  installRuntimes,
+  initProject,
   listSupportedRuntimes,
   listWorkflows,
-  prepareWorkflowRun,
-  uninstallRuntimes,
+  readConfig,
+  readProjectManifest,
+  removeProject,
 };

package/src/engine/install.js

@@ -1,222 +1,126 @@
 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 { listWorkflows } = require('./workflow-registry');
+const { listSkills } = require('./skill-registry');
 const { getRuntimeAdapter, listSupportedRuntimes } = 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');
+const SUPPORTED_AGENT_IDS = ['claude', 'copilot', 'antigravity'];
 
-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,
 };