@exchanet/enet 1.0.6 → 1.0.8

package/.enet/modular-design.md

@@ -1,13 +1,13 @@
-# METHOD REFLEX — Agent Instructions
+# METHOD MODULAR DESIGN — 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.
+You are building a modular application using Method Modular Design. 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.
+Estás construyendo una aplicación modular usando Method Modular Design. 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.**
@@ -133,4 +133,4 @@ Before marking any module complete / Antes de marcar cualquier módulo como comp
 ---
 
 *For full documentation / Para documentación completa: `METHOD.md`*
-*Method REFLEX v1.0.0 · @exchanet · MIT*
+*Method Modular Design v1.0.0 · @exchanet · MIT*

package/manifest.schema.json

@@ -0,0 +1,191 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/exchanet/method-reflex/manifest.schema.json",
+  "title": "Method REFLEX — Module Manifest",
+  "description": "Universal contract for self-describing modules. Every module must have a valid manifest.",
+  "type": "object",
+  "required": ["id", "name", "version", "type", "section"],
+  "additionalProperties": false,
+
+  "definitions": {
+    "handlerRef": {
+      "type": "string",
+      "pattern": "^[A-Z][a-zA-Z0-9]*\\.[a-z][a-zA-Z0-9]*$",
+      "description": "ClassName.methodName — e.g. ActivityLogger.getAll"
+    },
+    "capabilityType": {
+      "type": "string",
+      "enum": ["view", "action", "metric", "widget", "page", "theme", "component-override"]
+    },
+    "uiWidget": {
+      "type": "string",
+      "enum": ["text", "textarea", "number", "slider", "toggle", "select", "multiselect", "code", "color", "date", "tags"]
+    },
+    "settingType": {
+      "type": "string",
+      "enum": ["integer", "number", "string", "boolean", "select", "multiselect"]
+    }
+  },
+
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9-]*$",
+      "minLength": 2,
+      "maxLength": 64,
+      "description": "Unique module identifier. kebab-case. Used in URLs, API paths, and settings namespace."
+    },
+
+    "name": {
+      "type": "string",
+      "minLength": 2,
+      "maxLength": 100,
+      "description": "Human-readable module name. Shown in Admin Panel navigation."
+    },
+
+    "version": {
+      "type": "string",
+      "pattern": "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)$",
+      "description": "Semantic version: major.minor.patch"
+    },
+
+    "type": {
+      "type": "string",
+      "enum": ["core", "functional", "integration", "ui"],
+      "description": "core: system-level. functional: business logic. integration: external services. ui: themes and components."
+    },
+
+    "section": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9-]*$",
+      "description": "Admin Panel navigation group. Modules with the same section are grouped together."
+    },
+
+    "description": {
+      "type": "string",
+      "maxLength": 500,
+      "description": "Optional. Human-readable description of the module."
+    },
+
+    "icon": {
+      "type": "string",
+      "description": "Optional. Icon name from the project's icon library."
+    },
+
+    "dependencies": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^[a-z][a-z0-9-]*$"
+      },
+      "description": "Module IDs that must be booted before this module."
+    },
+
+    "hooks": {
+      "type": "object",
+      "patternProperties": {
+        "^[a-z][a-z0-9]*(\\.[a-z][a-z0-9]*)*$": {
+          "$ref": "#/definitions/handlerRef"
+        }
+      },
+      "additionalProperties": false,
+      "description": "Events this module listens to. Format: { 'event.name': 'ClassName.method' }"
+    },
+
+    "settings": {
+      "type": "object",
+      "patternProperties": {
+        "^[a-z][a-z0-9_]*$": {
+          "type": "object",
+          "required": ["type", "label", "default"],
+          "additionalProperties": false,
+          "properties": {
+            "type": { "$ref": "#/definitions/settingType" },
+            "label": { "type": "string" },
+            "description": { "type": "string" },
+            "default": {},
+            "ui": { "$ref": "#/definitions/uiWidget" },
+            "options": {
+              "type": "array",
+              "items": {
+                "oneOf": [
+                  { "type": "string" },
+                  {
+                    "type": "object",
+                    "required": ["label", "value"],
+                    "properties": {
+                      "label": { "type": "string" },
+                      "value": {}
+                    }
+                  }
+                ]
+              },
+              "description": "Required when type is select or multiselect."
+            },
+            "min": { "type": "number" },
+            "max": { "type": "number" },
+            "required": { "type": "boolean", "default": false }
+          }
+        }
+      },
+      "additionalProperties": false,
+      "description": "Configuration fields. Auto-rendered as forms in Admin Panel. Read via context.settings.get('key'). Never hardcode."
+    },
+
+    "capabilities": {
+      "type": "array",
+      "minItems": 0,
+      "items": {
+        "type": "object",
+        "required": ["type", "label"],
+        "additionalProperties": false,
+        "properties": {
+          "type": { "$ref": "#/definitions/capabilityType" },
+          "label": { "type": "string" },
+          "description": { "type": "string" },
+          "icon": { "type": "string" },
+          "data": {
+            "$ref": "#/definitions/handlerRef",
+            "description": "Handler that returns data. Required for: view, metric, widget."
+          },
+          "handler": {
+            "$ref": "#/definitions/handlerRef",
+            "description": "Handler that executes an operation. Required for: action."
+          },
+          "component": {
+            "type": "string",
+            "pattern": "^[A-Z][a-zA-Z0-9]*$",
+            "description": "Custom UI component name. For widget and page types."
+          },
+          "route": {
+            "type": "string",
+            "pattern": "^/[a-z0-9-/]*$",
+            "description": "URL route for page capabilities. Relative to /admin/{module-id}/"
+          },
+          "dangerous": {
+            "type": "boolean",
+            "default": false,
+            "description": "If true, Admin Panel shows a confirmation dialog before executing."
+          },
+          "permissions": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^[a-z][a-z0-9-]*:[a-z][a-z0-9-]*$"
+            },
+            "description": "Required permissions. Format: 'scope:action' e.g. 'users:delete'"
+          },
+          "target": {
+            "type": "string",
+            "description": "For component-override: the component name to replace."
+          },
+          "variables": {
+            "type": "object",
+            "description": "For theme capabilities: CSS custom property values."
+          }
+        }
+      },
+      "description": "What this module exposes. Each capability becomes a UI element in Admin Panel or dashboard."
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exchanet/enet",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "enet — exchanet methods manager. Install, scaffold and manage AI coding methods.",
   "bin": {
     "enet": "src/index.js"
@@ -25,13 +25,17 @@
   },
   "keywords": [
     "exchanet",
-    "method-reflex",
+    "method-modular-design",
+    "method-enterprise-builder",
+    "method-iris",
     "method-pdca-t",
+    "military-grade",
     "modular-architecture",
     "vibe-coding",
     "cursor",
     "windsurf",
     "copilot",
+    "claudecode",
     "ai-coding"
   ],
   "author": "Francisco J Bernades (@exchanet)",

package/registry.json

@@ -25,8 +25,8 @@
       "id": "pdca-t",
       "name": "Method PDCA-T",
       "description": "≥99% test coverage, zero vulnerabilities, systematic quality validation cycles. Use alongside Modular Design for pro-grade results.",
-      "repo": "exchanet/method_pdca-t_coding_Cursor",
-      "version": "1.0.0",
+      "repo": "exchanet/method_pdca-t_coding",
+      "version": "3.0.0",
       "tags": ["quality", "testing", "security", "coverage", "validation"],
       "adapters": {
         "cursor":      ".cursor/rules/METHOD-PDCA-T.md",

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/rules', '.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',
+    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 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'
-  },
-  windsurf: {
-    name: 'Windsurf',
-    signals: ['.windsurfrules', '.windsurf'],
-    installDir: '.',
-    filename: '.windsurfrules',
-    configNote: 'Appended to .windsurfrules'
+    configNote: 'Written to ~/.claude/CLAUDE.md — Claude Code reads this automatically'
   },
   copilot: {
     name: 'GitHub Copilot',
-    signals: ['.github/copilot-instructions.md'],
-    installDir: '.github',
+    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)
 }