@exchanet/enet 1.0.4 → 1.0.7

package/.enet/modular-design.md

@@ -0,0 +1,136 @@
+# METHOD REFLEX — Agent Instructions
+> Universal Modular Architecture · v1.0.0 · @exchanet
+
+---
+
+## YOUR PRIMARY DIRECTIVE / TU DIRECTIVA PRINCIPAL
+
+You are building a modular application using Method REFLEX. Every module you create must be self-describing via a `manifest.json` file. The manifest is written **before any code**. The system reads manifests to automatically generate the Admin Panel, dashboard, and settings UI. You never manually wire backend logic to the Admin Panel — the manifest does it.
+
+Estás construyendo una aplicación modular usando Method REFLEX. Cada módulo que crees debe ser auto-descriptivo a través de un archivo `manifest.json`. El manifest se escribe **antes de cualquier código**. El sistema lee los manifests para generar automáticamente el Panel Admin, dashboard y UI de configuración. Nunca cablearás manualmente la lógica backend al Panel Admin — el manifest lo hace.
+
+**If a module has no manifest, it does not exist.**
+**Si un módulo no tiene manifest, no existe.**
+
+---
+
+## ABSOLUTE RULES / REGLAS ABSOLUTAS
+
+1. **No manifest = module does not exist.** Core rejects modules without valid `manifest.json`.
+2. **Manifest before code.** Complete manifest before any handler, model, or component.
+3. **Zero hardcoded configuration.** Every configurable value lives in `manifest.settings`, read via `context.settings.get("key")`.
+4. **Core has no business logic.** Domain logic lives in modules only.
+5. **Admin Panel is a renderer.** Never code it to show a specific module — modules declare capabilities, Admin Panel renders them.
+6. **A module is complete only when the Admin Panel reflects it correctly.**
+7. **Removing a module folder requires zero code changes elsewhere.**
+
+---
+
+## WORKFLOW / FLUJO DE TRABAJO
+
+### Starting a new project / Nuevo proyecto:
+1. Ask for spectech if not provided (stack, database, deploy target)
+2. Declare the architecture you will build
+3. **Wait for confirmation before writing any code**
+4. Build Core → Manifest schema → Modules → Admin Panel
+
+### Adding a module / Añadir un módulo:
+1. Write complete `manifest.json` (all settings + capabilities + hooks)
+2. Validate against `manifest.schema.json`
+3. Implement all handlers referenced in manifest
+4. Place in modules directory (Core discovers automatically)
+5. Boot system and verify module appears in Admin Panel
+6. Build custom UI components only if manifest declares a `component` field
+
+### When you cannot complete a manifest / Cuando no puedes completar un manifest:
+
+**STOP. Ask the user:**
+
+```
+"I cannot complete the manifest for [module name] because I don't understand 
+[specific aspect]. Before I continue, I need you to clarify: [specific question]"
+
+"No puedo completar el manifest de [nombre del módulo] porque no entiendo 
+[aspecto específico]. Antes de continuar, necesito que aclares: [pregunta específica]"
+```
+
+Do not proceed. Do not create a partial manifest. Do not make assumptions. Wait.
+No continúes. No crees un manifest parcial. No hagas suposiciones. Espera.
+
+---
+
+## MANIFEST FORMAT / FORMATO DEL MANIFEST
+
+```json
+{
+  "id": "module-id",
+  "name": "Human Name",
+  "version": "1.0.0",
+  "type": "functional",
+  "section": "admin-section",
+  "dependencies": [],
+  "hooks": { "event.name": "ClassName.method" },
+  "settings": {
+    "key": {
+      "type": "integer|string|boolean|select",
+      "label": "Label",
+      "default": null,
+      "ui": "slider|toggle|text|select"
+    }
+  },
+  "capabilities": [
+    { "type": "view",   "label": "Label", "data": "ClassName.method" },
+    { "type": "action", "label": "Label", "handler": "ClassName.method", "dangerous": false },
+    { "type": "metric", "label": "Label", "data": "ClassName.method" },
+    { "type": "widget", "label": "Label", "data": "ClassName.method", "component": "ComponentName" }
+  ]
+}
+```
+
+---
+
+## WHAT THE CORE MUST IMPLEMENT / QUÉ DEBE IMPLEMENTAR EL CORE
+
+- Module discovery — scan modules dir for valid manifests
+- Manifest validation — reject invalid manifests with clear errors (never silent)
+- Dependency resolution — boot in correct order
+- Handler registry — map `ClassName.method` references to implementations
+- Hook system — dispatch events to declared handlers
+- Settings store — persistent, namespaced by module ID, initialized from defaults
+- REFLEX engine — read all manifests, build Admin nav, dashboard, settings schemas
+- Admin API — standard endpoints (same in every project, every stack)
+
+```
+GET  /api/admin/manifest-registry
+GET  /api/admin/navigation
+GET  /api/admin/settings/:moduleId
+POST /api/admin/settings/:moduleId
+GET  /api/admin/dashboard
+POST /api/admin/action/:moduleId/:actionId
+GET  /api/admin/health
+```
+
+**The Core has ZERO business logic. / El Core tiene CERO lógica de negocio.**
+
+---
+
+## COMPLETION CHECKLIST / CHECKLIST DE COMPLETITUD
+
+Before marking any module complete / Antes de marcar cualquier módulo como completo:
+
+- [ ] `manifest.json` valid / válido
+- [ ] All declared handlers implemented / Todos los handlers declarados implementados
+- [ ] Zero hardcoded values — all settings use `context.settings.get()` / Cero hardcoded
+- [ ] Module appears in Admin Panel navigation / El módulo aparece en la navegación del Panel Admin
+- [ ] All views render with data / Todas las vistas renderizan con datos
+- [ ] All actions execute correctly / Todas las acciones ejecutan correctamente
+- [ ] Dangerous actions show confirmation dialog / Las acciones peligrosas muestran diálogo
+- [ ] All metrics show in dashboard / Todas las métricas aparecen en el dashboard
+- [ ] All settings render and save correctly / Todos los settings renderizan y guardan
+- [ ] Adding this module required zero Core changes / Añadir el módulo requirió cero cambios en el Core
+- [ ] Removing module folder removes it completely from Admin Panel / Eliminar la carpeta lo elimina del Panel Admin
+
+---
+
+*For full documentation / Para documentación completa: `METHOD.md`*
+*Method REFLEX v1.0.0 · @exchanet · MIT*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exchanet/enet",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "description": "enet — exchanet methods manager. Install, scaffold and manage AI coding methods.",
   "bin": {
     "enet": "src/index.js"

package/src/commands/install.js

@@ -2,11 +2,11 @@ import chalk from 'chalk'
 import ora from 'ora'
 import fs from 'fs-extra'
 import path from 'path'
-import { detectAgent, getInstallPath, AGENTS } from '../utils/agent-detector.js'
-import { getMethod } from '../utils/registry.js'
-import { fetchFromGitHub } from '../utils/registry.js'
+import { detectSystemAgents, getInstallPath, AGENTS } from '../utils/agent-detector.js'
+import { getMethod, fetchFromGitHub } from '../utils/registry.js'
 
 export async function installCommand(methodId, options) {
+  // Load method from registry
   const spinner = ora('Fetching registry...').start()
   const method = await getMethod(methodId).catch(() => null)
   spinner.stop()
@@ -17,40 +17,92 @@ export async function installCommand(methodId, options) {
     process.exit(1)
   }
 
-  // Detect or force agent
-  let agent
+  // Determine target agents
+  let targetAgents = []
+
   if (options.agent) {
+    // --agent flag: install for a specific agent only
     if (!AGENTS[options.agent]) {
       console.log(chalk.red(`  ✗ Unknown agent: "${options.agent}"`))
-      console.log(chalk.dim(`  Valid: cursor, windsurf, copilot, generic\n`))
+      console.log(chalk.dim(`  Valid: ${Object.keys(AGENTS).filter(k => k !== 'generic').join(', ')}\n`))
       process.exit(1)
     }
-    agent = { key: options.agent, ...AGENTS[options.agent] }
+    targetAgents = [{ key: options.agent, ...AGENTS[options.agent] }]
+
   } else {
-    agent = await detectAgent()
+    // Detect all agents installed on the system
+    const detected = await detectSystemAgents()
+
+    if (detected.length === 0) {
+      console.log(chalk.yellow('  ⚠ No AI agents detected on this system.'))
+      console.log(chalk.dim(`  Use ${chalk.white('--agent <name>')} to force an agent.`))
+      console.log(chalk.dim(`  Valid: cursor, windsurf, antigravity, claudecode, copilot, generic\n`))
+      process.exit(1)
+    }
+
+    if (detected.length === 1 || options.global) {
+      // Only one detected, or --global flag: install for all without asking
+      targetAgents = detected
+    } else {
+      // Multiple agents detected: ask the user
+      console.log(chalk.white(`\n  Detected ${detected.length} agents on this system:\n`))
+      detected.forEach((a, i) => console.log(chalk.dim(`  [${i + 1}] ${a.name}`)))
+      console.log(chalk.dim(`  [${detected.length + 1}] All of the above\n`))
+
+      const { createInterface } = await import('readline')
+      const rl = createInterface({ input: process.stdin, output: process.stdout })
+      const answer = await new Promise(resolve => {
+        rl.question(chalk.white('  Install for which agent(s)? '), resolve)
+      })
+      rl.close()
+
+      const choice = parseInt(answer.trim())
+      if (choice === detected.length + 1) {
+        targetAgents = detected
+      } else if (choice >= 1 && choice <= detected.length) {
+        targetAgents = [detected[choice - 1]]
+      } else {
+        console.log(chalk.red('\n  Invalid choice. Cancelled.\n'))
+        process.exit(1)
+      }
+    }
   }
 
-  console.log(chalk.dim(`  Method : ${chalk.white(method.name)}`))
-  console.log(chalk.dim(`  Agent  : ${chalk.white(agent.name)}${options.agent ? '' : chalk.dim(' (auto-detected)')}`))
-  console.log(chalk.dim(`  Source : ${chalk.white(`github.com/${method.repo}`)}\n`))
+  console.log()
 
-  const fetchSpinner = ora(`Fetching adapter...`).start()
+  // Install for each target agent
+  let schemaInstalled = false
+  for (const agent of targetAgents) {
+    await installForAgent(method, agent, options, schemaInstalled)
+    schemaInstalled = true // only install schema once
+  }
+
+  printHints(methodId)
+}
+
+async function installForAgent(method, agent, options, skipExtras = false) {
+  const isGlobal = options.global || false
+  const adapterKey = method.adapters[agent.key] ? agent.key : 'generic'
+  const adapterPath = method.adapters[adapterKey]
+
+  if (isGlobal && !agent.globalInstallDir) {
+    console.log(chalk.yellow(`  ⚠ ${agent.name} does not support global install — skipping`))
+    return
+  }
+
+  const spinner = ora(`Installing for ${agent.name}${isGlobal ? ' (global)' : ''}...`).start()
 
   try {
-    const adapterPath = method.adapters[agent.key] ?? method.adapters.generic
     const content = await fetchFromGitHub(method.repo, adapterPath)
-
-    const installPath = options.global
-      ? path.join(process.env.HOME || process.env.USERPROFILE, '.enet', `${methodId}.md`)
-      : getInstallPath(agent, methodId)
+    const installPath = getInstallPath(agent, method.id, { global: isGlobal })
 
     await fs.ensureDir(path.dirname(installPath))
 
-    // Windsurf appends, others overwrite
+    // Windsurf global appends to global_rules.md
     if (agent.key === 'windsurf' && await fs.pathExists(installPath)) {
       const existing = await fs.readFile(installPath, 'utf8')
       if (existing.includes(method.name)) {
-        fetchSpinner.warn(chalk.yellow(`${method.name} already installed`))
+        spinner.warn(chalk.yellow(`${agent.name} — already installed`))
         return
       }
       await fs.appendFile(installPath, `\n\n---\n\n${content}`)
@@ -58,32 +110,29 @@ export async function installCommand(methodId, options) {
       await fs.writeFile(installPath, content)
     }
 
-    fetchSpinner.succeed(chalk.green(`${method.name} installed`))
-    console.log(chalk.dim(`  → ${path.relative(process.cwd(), installPath)}`))
+    spinner.succeed(chalk.green(`${agent.name} — installed`))
+    console.log(chalk.dim(`  → ${installPath}`))
     console.log(chalk.dim(`  ${agent.configNote}\n`))
 
-    // Download extras (e.g. manifest.schema.json for modular-design)
-    if (method.extras) {
-      for (const [key, filePath] of Object.entries(method.extras)) {
-        const extraSpinner = ora(`Fetching ${key}...`).start()
-        try {
-          const extraContent = await fetchFromGitHub(method.repo, filePath)
-          const extraOut = path.join(process.cwd(), path.basename(filePath))
-          await fs.writeFile(extraOut, extraContent)
-          extraSpinner.succeed(chalk.dim(`${key} → ${path.basename(filePath)}`))
-        } catch {
-          extraSpinner.warn(chalk.dim(`${key} not available (non-critical)`))
-        }
+  } catch (err) {
+    spinner.fail(chalk.red(`${agent.name} — ${err.message}`))
+    return
+  }
+
+  // Download extras (schema, etc.) once
+  if (!skipExtras && method.extras) {
+    for (const [key, filePath] of Object.entries(method.extras)) {
+      const extraSpinner = ora(`Fetching ${key}...`).start()
+      try {
+        const extraContent = await fetchFromGitHub(method.repo, filePath)
+        const extraOut = path.join(process.cwd(), path.basename(filePath))
+        await fs.writeFile(extraOut, extraContent)
+        extraSpinner.succeed(chalk.dim(`${key} → ${path.basename(filePath)}`))
+      } catch {
+        extraSpinner.warn(chalk.dim(`${key} not available (non-critical)`))
       }
-      console.log()
     }
-
-    printHints(methodId)
-
-  } catch (err) {
-    fetchSpinner.fail(chalk.red(`Failed: ${err.message}`))
-    console.log(chalk.dim('  Check your internet connection and try again.\n'))
-    process.exit(1)
+    console.log()
   }
 }
 
@@ -95,7 +144,7 @@ function printHints(methodId) {
     console.log(chalk.dim(`  3. Agent builds Core → modules → Admin Panel`))
     console.log()
     console.log(chalk.dim(`  ${chalk.white('enet new module <name>')}   scaffold your first module`))
-    console.log(chalk.dim(`  ${chalk.white('enet validate')}            check manifests at any time\n`))
+    console.log(chalk.dim(`  ${chalk.white('enet validate')}             check manifests at any time\n`))
   }
   if (methodId === 'pdca-t') {
     console.log(chalk.dim(`  PDCA-T adds quality validation to your workflow.`))

package/src/utils/agent-detector.js

@@ -1,70 +1,127 @@
 import fs from 'fs-extra'
 import path from 'path'
+import os from 'os'
+
+const HOME = os.homedir()
 
 export const AGENTS = {
   cursor: {
     name: 'Cursor',
-    signals: ['.cursor'],
-    installDir: '.cursor/rules',
+    systemSignals: [
+      path.join(HOME, '.cursor')
+    ],
+    projectSignals: ['.cursor/rules', '.cursor'],
+    projectInstallDir: '.cursor/rules',
+    globalInstallDir: path.join(HOME, '.cursor', 'rules'),
     filename: 'enet-{id}.md',
     configNote: 'Rule auto-applies to all files (alwaysApply: true)'
   },
   windsurf: {
     name: 'Windsurf',
-    signals: ['.windsurfrules', '.windsurf'],
-    installDir: '.',
+    systemSignals: [
+      path.join(HOME, '.codeium', 'windsurf')
+    ],
+    projectSignals: ['.windsurfrules', '.windsurf'],
+    projectInstallDir: '.',
+    globalInstallDir: path.join(HOME, '.codeium', 'windsurf', 'memories'),
+    globalFilename: 'global_rules.md',
     filename: '.windsurfrules',
-    configNote: 'Appended to .windsurfrules'
-  },
-  copilot: {
-    name: 'GitHub Copilot',
-    signals: ['.github/copilot-instructions.md', '.github'],
-    installDir: '.github',
-    filename: 'copilot-instructions.md',
-    configNote: 'Written to .github/copilot-instructions.md'
+    configNote: 'Appended to global_rules.md'
   },
   antigravity: {
     name: 'Antigravity (Google)',
-    signals: ['.agent/rules', '.agent'],
-    installDir: '.agent/rules',
+    systemSignals: [
+      path.join(HOME, '.gemini', 'antigravity')
+    ],
+    projectSignals: ['.agent/rules', '.agent'],
+    projectInstallDir: '.agent/rules',
+    globalInstallDir: path.join(HOME, '.gemini', 'antigravity', 'skills', 'method-modular-design'),
+    globalFilename: 'SKILL.md',
     filename: 'enet-{id}.md',
-    configNote: 'Rule saved to .agent/rules/ — set activation to Always On in Antigravity'
+    configNote: 'Skill saved — set activation to Always On in Antigravity'
   },
   claudecode: {
     name: 'Claude Code',
-    signals: ['CLAUDE.md', '.claude'],
-    installDir: '.',
+    systemSignals: [
+      path.join(HOME, '.claude')
+    ],
+    projectSignals: ['CLAUDE.md', '.claude'],
+    projectInstallDir: '.',
+    globalInstallDir: path.join(HOME, '.claude'),
+    globalFilename: 'CLAUDE.md',
     filename: 'CLAUDE.md',
-    configNote: 'Written to CLAUDE.md — Claude Code reads this file automatically'
+    configNote: 'Written to ~/.claude/CLAUDE.md — Claude Code reads this automatically'
+  },
+  copilot: {
+    name: 'GitHub Copilot',
+    systemSignals: [],
+    projectSignals: ['.github/copilot-instructions.md'],
+    projectInstallDir: '.github',
+    globalInstallDir: null,
+    filename: 'copilot-instructions.md',
+    configNote: 'Written to .github/copilot-instructions.md'
   },
   generic: {
     name: 'Generic Agent',
-    signals: [],
-    installDir: '.enet',
+    systemSignals: [],
+    projectSignals: [],
+    projectInstallDir: '.enet',
+    globalInstallDir: null,
     filename: '{id}.md',
     configNote: 'Saved to .enet/ — paste contents into your agent\'s context'
   }
 }
 
 /**
- * Detects which AI agent is active in the current project.
+ * Detects ALL agents installed on the system by checking known global paths.
  */
-export async function detectAgent(cwd = process.cwd()) {
+export async function detectSystemAgents() {
+  const found = []
   for (const [key, agent] of Object.entries(AGENTS)) {
     if (key === 'generic') continue
-    for (const signal of agent.signals) {
+    for (const signal of agent.systemSignals) {
+      if (await fs.pathExists(signal)) {
+        found.push({ key, ...agent })
+        break
+      }
+    }
+  }
+  return found
+}
+
+/**
+ * Detects ALL agents present in the current project.
+ */
+export async function detectProjectAgents(cwd = process.cwd()) {
+  const found = []
+  for (const [key, agent] of Object.entries(AGENTS)) {
+    if (key === 'generic') continue
+    for (const signal of agent.projectSignals) {
       if (await fs.pathExists(path.join(cwd, signal))) {
-        return { key, ...agent }
+        found.push({ key, ...agent })
+        break
       }
     }
   }
-  return { key: 'generic', ...AGENTS.generic }
+  return found
 }
 
 /**
- * Returns the full install path for a method adapter.
+ * Returns the first detected agent (legacy, used by status/doctor).
  */
-export function getInstallPath(agent, methodId, cwd = process.cwd()) {
+export async function detectAgent(cwd = process.cwd()) {
+  const agents = await detectProjectAgents(cwd)
+  return agents[0] ?? { key: 'generic', ...AGENTS.generic }
+}
+
+/**
+ * Returns the install path for a method adapter.
+ */
+export function getInstallPath(agent, methodId, { global = false, cwd = process.cwd() } = {}) {
+  if (global) {
+    const filename = agent.globalFilename ?? agent.filename.replace('{id}', methodId)
+    return path.join(agent.globalInstallDir, filename)
+  }
   const filename = agent.filename.replace('{id}', methodId)
-  return path.join(cwd, agent.installDir, filename)
+  return path.join(cwd, agent.projectInstallDir, filename)
 }