@exchanet/enet 1.0.0

package/README.md

@@ -0,0 +1,188 @@
+# ◆ enet — exchanet methods manager
+
+Install, scaffold and manage exchanet AI coding methods in any project, with any agent.
+
+```bash
+npm install -g @exchanet/enet
+```
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![npm](https://img.shields.io/npm/v/@exchanet/enet.svg)](https://www.npmjs.com/package/@exchanet/enet)
+[![Node: >=18](https://img.shields.io/badge/node-%3E%3D18-green.svg)]()
+
+---
+
+## What is enet?
+
+`enet` is the package manager for exchanet methods. It installs AI coding method adapters directly into your project — in the right place for your agent — and provides tools to scaffold modules, validate manifests, and keep everything up to date.
+
+Think of it as `brew` or `npm`, but for AI coding architecture methods.
+
+---
+
+## Available Methods
+
+| Method | What it does |
+|---|---|
+| `reflex` | Universal modular architecture. Auto-generated Admin Panel, zero hardcoded config. |
+| `pdca-t` | ≥99% test coverage, zero vulnerabilities, systematic quality validation. |
+| `iris` | Continuous improvement of existing systems without breaking architecture. |
+| `enterprise-builder` | Large-scale planning for complex projects before writing code. |
+
+The registry is live — new methods appear automatically without updating enet.
+
+---
+
+## Usage
+
+### Install a method
+
+```bash
+enet install reflex
+enet install pdca-t
+enet install iris
+enet install enterprise-builder
+```
+
+enet detects your AI agent automatically and places the adapter in the right location:
+
+| Agent detected | Installs to |
+|---|---|
+| Cursor | `.cursor/rules/enet-reflex.md` |
+| Windsurf | Appended to `.windsurfrules` |
+| GitHub Copilot | `.github/copilot-instructions.md` |
+| None detected | `.enet/reflex.md` |
+
+Override with `--agent cursor\|windsurf\|copilot\|generic`.
+
+### See all available methods
+
+```bash
+enet list
+enet list --installed
+```
+
+### Project status and health
+
+```bash
+enet status    # installed methods + detected agent
+enet doctor    # full diagnostic — manifests, schema, agent, Node version
+```
+
+### Scaffold a new module
+
+```bash
+enet new module products
+enet new module activity-logger --section monitoring
+enet new ui-pack dark-theme
+enet new integration stripe --section billing
+```
+
+Generates `manifest.json` + handler + README. Manifest first, always.
+
+### Create a manifest interactively
+
+```bash
+enet init
+enet init --json    # print to stdout without writing
+```
+
+### Validate manifests
+
+```bash
+enet validate              # validate all modules in project
+enet validate --all        # recursive
+enet validate --strict     # warnings become errors
+```
+
+### Keep methods up to date
+
+```bash
+enet update              # update all installed methods
+enet update reflex       # update a specific method
+```
+
+---
+
+## How it works
+
+1. `enet install reflex` fetches `registry.json` from this repo
+2. Finds the repo for `reflex` (`exchanet/method_reflex`)
+3. Detects your agent (Cursor, Windsurf, Copilot...)
+4. Downloads the right adapter from GitHub in real time
+5. Writes it to the correct location in your project
+
+The adapter content always comes live from the source repo. `enet update` re-fetches to get the latest version.
+
+---
+
+## The Registry
+
+Methods are defined in [`registry.json`](./registry.json) in this repo. The CLI fetches it on every run — no local state, always current.
+
+To add a new exchanet method to the registry, add an entry to `registry.json` and open a PR. No CLI code changes needed.
+
+```json
+{
+  "methods": {
+    "your-method": {
+      "name": "Method Name",
+      "description": "What it does.",
+      "repo": "exchanet/method_your_repo",
+      "adapters": {
+        "cursor":   "adapters/cursor.md",
+        "windsurf": "adapters/windsurf.md",
+        "copilot":  "adapters/copilot.md",
+        "generic":  "adapters/generic.md"
+      }
+    }
+  }
+}
+```
+
+---
+
+## Requirements
+
+- Node.js 18 or higher
+- An AI coding agent (Cursor, Windsurf, GitHub Copilot, or any agent)
+
+---
+
+## Repository Structure
+
+```
+exchanet/enet/
+├── registry.json          ← source of truth for all methods
+├── README.md
+├── package.json           ← published as @exchanet/enet
+└── src/
+    ├── index.js           ← entry point, command definitions
+    ├── commands/
+    │   ├── install.js     ← enet install
+    │   ├── list.js        ← enet list
+    │   ├── init.js        ← enet init
+    │   ├── validate.js    ← enet validate
+    │   ├── new.js         ← enet new
+    │   ├── update.js      ← enet update
+    │   ├── status.js      ← enet status
+    │   └── doctor.js      ← enet doctor
+    └── utils/
+        ├── registry.js    ← loads registry.json from GitHub, caches locally
+        └── agent-detector.js ← detects Cursor / Windsurf / Copilot
+```
+
+---
+
+## Publishing
+
+```bash
+cd enet
+npm publish --access public
+```
+
+---
+
+## License
+
+MIT — Francisco J Bernades ([@exchanet](https://github.com/exchanet))

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@exchanet/enet",
+  "version": "1.0.0",
+  "description": "enet — exchanet methods manager. Install, scaffold and manage AI coding methods.",
+  "bin": {
+    "enet": "./src/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "dev": "node src/index.js",
+    "test": "node --test"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "enquirer": "^2.4.1",
+    "ora": "^8.0.1",
+    "node-fetch": "^3.3.2",
+    "ajv": "^8.12.0",
+    "ajv-formats": "^3.0.1",
+    "fs-extra": "^11.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "exchanet",
+    "method-reflex",
+    "method-pdca-t",
+    "modular-architecture",
+    "vibe-coding",
+    "cursor",
+    "windsurf",
+    "copilot",
+    "ai-coding"
+  ],
+  "author": "Francisco J Bernades (@exchanet)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exchanet/enet"
+  },
+  "homepage": "https://github.com/exchanet/enet"
+}

package/registry.json

@@ -0,0 +1,65 @@
+{
+  "version": "1.0.0",
+  "updated": "2025-01-01",
+  "methods": {
+    "reflex": {
+      "id": "reflex",
+      "name": "Method REFLEX",
+      "description": "Universal modular architecture. Auto-generated Admin Panel, zero hardcoded config, self-describing modules via manifest.json.",
+      "repo": "exchanet/method_reflex",
+      "version": "1.0.0",
+      "tags": ["architecture", "modular", "admin-panel", "manifest", "core"],
+      "adapters": {
+        "cursor":   "adapters/cursor.md",
+        "windsurf": "adapters/windsurf.md",
+        "copilot":  "adapters/copilot.md",
+        "generic":  "adapters/generic.md"
+      },
+      "extras": {
+        "schema": "schemas/manifest.schema.json"
+      }
+    },
+    "pdca-t": {
+      "id": "pdca-t",
+      "name": "Method PDCA-T",
+      "description": "≥99% test coverage, zero vulnerabilities, systematic quality validation cycles. Use alongside REFLEX for pro-grade results.",
+      "repo": "exchanet/method_pdca-t_coding_Cursor",
+      "version": "1.0.0",
+      "tags": ["quality", "testing", "security", "coverage", "validation"],
+      "adapters": {
+        "cursor":   ".cursor/rules/METHOD-PDCA-T.md",
+        "windsurf": ".cursor/rules/METHOD-PDCA-T.md",
+        "copilot":  ".cursor/rules/METHOD-PDCA-T.md",
+        "generic":  ".cursor/rules/METHOD-PDCA-T.md"
+      }
+    },
+    "iris": {
+      "id": "iris",
+      "name": "Method IRIS",
+      "description": "Continuous improvement of existing systems. Diagnose, refactor and evolve without breaking architecture.",
+      "repo": "exchanet/method_IRIS",
+      "version": "1.0.0",
+      "tags": ["refactoring", "improvement", "evolution", "maintenance"],
+      "adapters": {
+        "cursor":   "adapters/cursor.md",
+        "windsurf": "adapters/windsurf.md",
+        "copilot":  "adapters/copilot.md",
+        "generic":  "adapters/generic.md"
+      }
+    },
+    "enterprise-builder": {
+      "id": "enterprise-builder",
+      "name": "Method Enterprise Builder",
+      "description": "Large-scale planning and architecture for complex projects. Define modules, dependencies and build order before writing code.",
+      "repo": "exchanet/method_enterprise_builder_planning",
+      "version": "1.0.0",
+      "tags": ["planning", "enterprise", "architecture", "scale"],
+      "adapters": {
+        "cursor":   "adapters/cursor.md",
+        "windsurf": "adapters/windsurf.md",
+        "copilot":  "adapters/copilot.md",
+        "generic":  "adapters/generic.md"
+      }
+    }
+  }
+}

package/src/commands/doctor.js

@@ -0,0 +1,127 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import path from 'path'
+import ora from 'ora'
+import { detectAgent, getInstallPath } from '../utils/agent-detector.js'
+import { getAllMethods } from '../utils/registry.js'
+
+export async function doctorCommand() {
+  const cwd = process.cwd()
+
+  const spinner = ora('Running diagnostics...').start()
+  const [methods, agent] = await Promise.all([getAllMethods(), detectAgent()])
+  spinner.stop()
+
+  console.log(chalk.white('  ◆ enet doctor\n'))
+
+  const checks = []
+
+  // Agent detected
+  checks.push({
+    label: `AI agent detected (${agent.name})`,
+    pass: agent.key !== 'generic',
+    hint: 'Create .cursor/, .windsurfrules, or .github/ to auto-detect your agent.'
+  })
+
+  // At least one method installed
+  let installedCount = 0
+  for (const method of methods) {
+    if (await fs.pathExists(getInstallPath(agent, method.id))) installedCount++
+  }
+  checks.push({
+    label: `Methods installed (${installedCount}/${methods.length})`,
+    pass: installedCount > 0,
+    hint: `Run: enet install reflex`
+  })
+
+  // manifest.schema.json
+  const hasSchema = await fs.pathExists(path.join(cwd, 'manifest.schema.json'))
+  checks.push({
+    label: 'manifest.schema.json present',
+    pass: hasSchema,
+    hint: 'Run: enet install reflex (downloads schema automatically)'
+  })
+
+  // Modules directory
+  const modulesDir = await findModulesDir(cwd)
+  checks.push({
+    label: modulesDir
+      ? `Modules directory (${path.relative(cwd, modulesDir)})`
+      : 'Modules directory',
+    pass: !!modulesDir,
+    hint: 'Create a modules/ directory for your first module.'
+  })
+
+  // Manifests valid
+  if (hasSchema && modulesDir) {
+    const manifests = await findManifests(modulesDir)
+    if (manifests.length > 0) {
+      const { valid, invalid } = await quickValidate(path.join(cwd, 'manifest.schema.json'), manifests)
+      checks.push({
+        label: `Manifests valid (${valid}/${manifests.length})`,
+        pass: invalid === 0,
+        hint: 'Run: enet validate --all'
+      })
+    }
+  }
+
+  // Node version
+  const nodeVersion = parseInt(process.version.replace('v', '').split('.')[0])
+  checks.push({
+    label: `Node.js ${process.version}`,
+    pass: nodeVersion >= 18,
+    hint: 'Upgrade to Node.js 18 or higher.'
+  })
+
+  // Print
+  let allPass = true
+  for (const check of checks) {
+    const icon = check.pass ? chalk.green('✓') : chalk.red('✗')
+    console.log(`  ${icon} ${check.pass ? chalk.white(check.label) : chalk.dim(check.label)}`)
+    if (!check.pass && check.hint) {
+      console.log(chalk.dim(`    → ${check.hint}`))
+    }
+    if (!check.pass) allPass = false
+  }
+
+  console.log()
+  if (allPass) {
+    console.log(chalk.green('  ✓ Everything looks good!\n'))
+  } else {
+    console.log(chalk.yellow('  ⚠ Some issues found. Follow the hints above.\n'))
+  }
+}
+
+async function findModulesDir(cwd) {
+  for (const dir of ['modules', 'packs', 'src/modules']) {
+    const full = path.join(cwd, dir)
+    if (await fs.pathExists(full)) return full
+  }
+  return null
+}
+
+async function findManifests(dir) {
+  const results = []
+  const entries = await fs.readdir(dir)
+  for (const entry of entries) {
+    const p = path.join(dir, entry, 'manifest.json')
+    if (await fs.pathExists(p)) results.push(p)
+  }
+  return results
+}
+
+async function quickValidate(schemaPath, manifests) {
+  const { default: Ajv } = await import('ajv')
+  const { default: addFormats } = await import('ajv-formats')
+  const schema = await fs.readJson(schemaPath)
+  const ajv = new Ajv({ allErrors: false })
+  addFormats(ajv)
+  const validate = ajv.compile(schema)
+  let valid = 0, invalid = 0
+  for (const p of manifests) {
+    try {
+      validate(await fs.readJson(p)) ? valid++ : invalid++
+    } catch { invalid++ }
+  }
+  return { valid, invalid }
+}

package/src/commands/init.js

@@ -0,0 +1,115 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import path from 'path'
+import { prompt } from 'enquirer'
+
+export async function initCommand(options) {
+  console.log(chalk.white('  Creating manifest.json\n'))
+  console.log(chalk.dim('  The manifest is the module. Complete it before writing any code.\n'))
+
+  try {
+    const basic = await prompt([
+      { type: 'input',  name: 'name',    message: 'Module name:', validate: v => v.length > 1 || 'Required' },
+      { type: 'input',  name: 'id',      message: 'Module ID (kebab-case):', validate: v => /^[a-z][a-z0-9-]*$/.test(v) || 'kebab-case only' },
+      { type: 'select', name: 'type',    message: 'Type:', choices: ['functional', 'integration', 'ui', 'core'] },
+      { type: 'input',  name: 'section', message: 'Admin section (e.g. monitoring):', validate: v => /^[a-z][a-z0-9-]*$/.test(v) || 'kebab-case only' }
+    ])
+
+    // Settings
+    const settings = {}
+    const { addSettings } = await prompt({ type: 'confirm', name: 'addSettings', message: 'Add configurable settings?', initial: true })
+
+    if (addSettings) {
+      let more = true
+      while (more) {
+        const { key } = await prompt({ type: 'input', name: 'key', message: '  Setting key (empty to finish):' })
+        if (!key) break
+
+        const details = await prompt([
+          { type: 'input',  name: 'label',   message: '  Label:' },
+          { type: 'select', name: 'type',    message: '  Type:', choices: ['integer', 'string', 'boolean', 'select'] },
+          { type: 'select', name: 'ui',      message: '  Widget:', choices: ['text', 'number', 'slider', 'toggle', 'select', 'textarea'] },
+          { type: 'input',  name: 'default', message: '  Default:' }
+        ])
+
+        settings[key] = {
+          type: details.type,
+          label: details.label,
+          default: parseDefault(details.default, details.type),
+          ui: details.ui
+        }
+
+        const { cont } = await prompt({ type: 'confirm', name: 'cont', message: '  Add another?', initial: false })
+        more = cont
+      }
+    }
+
+    // Capabilities
+    const capabilities = []
+    const { addCaps } = await prompt({ type: 'confirm', name: 'addCaps', message: 'Add capabilities?', initial: true })
+
+    if (addCaps) {
+      let more = true
+      while (more) {
+        const cap = await prompt([
+          { type: 'select', name: 'type',    message: '  Type:', choices: ['view', 'action', 'metric', 'widget', 'page'] },
+          { type: 'input',  name: 'label',   message: '  Label:', validate: v => v.length > 0 || 'Required' },
+          { type: 'input',  name: 'handler', message: '  Handler (ClassName.method):', validate: v => /^[A-Z][a-zA-Z0-9]*\.[a-z][a-zA-Z0-9]*$/.test(v) || 'Format: ClassName.method' }
+        ])
+
+        const capability = { type: cap.type, label: cap.label }
+        if (cap.type === 'action') {
+          capability.handler = cap.handler
+          const { dangerous } = await prompt({ type: 'confirm', name: 'dangerous', message: '  Mark as dangerous?', initial: false })
+          if (dangerous) capability.dangerous = true
+        } else {
+          capability.data = cap.handler
+        }
+        capabilities.push(capability)
+
+        const { cont } = await prompt({ type: 'confirm', name: 'cont', message: '  Add another?', initial: false })
+        more = cont
+      }
+    }
+
+    const manifest = {
+      id: basic.id,
+      name: basic.name,
+      version: '1.0.0',
+      type: basic.type,
+      section: basic.section,
+      dependencies: [],
+      hooks: {},
+      ...(Object.keys(settings).length > 0 && { settings }),
+      ...(capabilities.length > 0 && { capabilities })
+    }
+
+    const json = JSON.stringify(manifest, null, 2)
+
+    if (options.json) { console.log('\n' + json + '\n'); return }
+
+    const { confirm } = await prompt({ type: 'confirm', name: 'confirm', message: 'Write manifest.json here?', initial: true })
+    if (!confirm) { console.log('\n' + json + '\n'); return }
+
+    const outPath = path.join(process.cwd(), 'manifest.json')
+    if (await fs.pathExists(outPath)) {
+      const { overwrite } = await prompt({ type: 'confirm', name: 'overwrite', message: chalk.yellow('manifest.json exists. Overwrite?'), initial: false })
+      if (!overwrite) { console.log(chalk.dim('\n  Cancelled.\n')); return }
+    }
+
+    await fs.writeJson(outPath, manifest, { spaces: 2 })
+    console.log(chalk.green('\n  ✓ manifest.json created\n'))
+    console.log(chalk.dim(`  Implement the handlers, then run ${chalk.white('enet validate')}.\n`))
+
+  } catch (err) {
+    if (err === '') { console.log(chalk.dim('\n  Cancelled.\n')); return }
+    console.log(chalk.red(`\n  Error: ${err.message}\n`))
+    process.exit(1)
+  }
+}
+
+function parseDefault(value, type) {
+  if (type === 'integer') return parseInt(value) || 0
+  if (type === 'boolean') return value === 'true'
+  return value
+}

package/src/commands/install.js

@@ -0,0 +1,104 @@
+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'
+
+export async function installCommand(methodId, options) {
+  const spinner = ora('Fetching registry...').start()
+  const method = await getMethod(methodId).catch(() => null)
+  spinner.stop()
+
+  if (!method) {
+    console.log(chalk.red(`  ✗ Unknown method: "${methodId}"`))
+    console.log(chalk.dim(`  Run ${chalk.white('enet list')} to see available methods.\n`))
+    process.exit(1)
+  }
+
+  // Detect or force agent
+  let agent
+  if (options.agent) {
+    if (!AGENTS[options.agent]) {
+      console.log(chalk.red(`  ✗ Unknown agent: "${options.agent}"`))
+      console.log(chalk.dim(`  Valid: cursor, windsurf, copilot, generic\n`))
+      process.exit(1)
+    }
+    agent = { key: options.agent, ...AGENTS[options.agent] }
+  } else {
+    agent = await detectAgent()
+  }
+
+  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`))
+
+  const fetchSpinner = ora(`Fetching adapter...`).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)
+
+    await fs.ensureDir(path.dirname(installPath))
+
+    // Windsurf appends, others overwrite
+    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`))
+        return
+      }
+      await fs.appendFile(installPath, `\n\n---\n\n${content}`)
+    } else {
+      await fs.writeFile(installPath, content)
+    }
+
+    fetchSpinner.succeed(chalk.green(`${method.name} installed`))
+    console.log(chalk.dim(`  → ${path.relative(process.cwd(), installPath)}`))
+    console.log(chalk.dim(`  ${agent.configNote}\n`))
+
+    // Download extras (e.g. manifest.schema.json for reflex)
+    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)`))
+        }
+      }
+      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)
+  }
+}
+
+function printHints(methodId) {
+  if (methodId === 'reflex') {
+    console.log(chalk.dim('  Next:'))
+    console.log(chalk.dim(`  1. Give your agent a spectech (stack + modules needed)`))
+    console.log(chalk.dim(`  2. Agent declares architecture — confirm it`))
+    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`))
+  }
+  if (methodId === 'pdca-t') {
+    console.log(chalk.dim(`  PDCA-T adds quality validation to your workflow.`))
+    console.log(chalk.dim(`  Works best alongside ${chalk.white('enet install reflex')}.\n`))
+  }
+}

package/src/commands/list.js

@@ -0,0 +1,56 @@
+import chalk from 'chalk'
+import ora from 'ora'
+import fs from 'fs-extra'
+import { getAllMethods } from '../utils/registry.js'
+import { detectAgent, getInstallPath } from '../utils/agent-detector.js'
+
+export async function listCommand(options) {
+  const spinner = ora('Fetching registry...').start()
+
+  let methods
+  try {
+    methods = await getAllMethods()
+    spinner.stop()
+  } catch (err) {
+    spinner.fail(chalk.red(`Could not load registry: ${err.message}`))
+    process.exit(1)
+  }
+
+  const agent = await detectAgent()
+
+  console.log(chalk.dim(`  Agent: ${chalk.white(agent.name)}\n`))
+
+  if (options.installed) {
+    console.log(chalk.white('  Installed methods:\n'))
+  } else {
+    console.log(chalk.white(`  Available methods (${methods.length}):\n`))
+  }
+
+  let shown = 0
+
+  for (const method of methods) {
+    const installPath = getInstallPath(agent, method.id)
+    const isInstalled = await fs.pathExists(installPath)
+
+    if (options.installed && !isInstalled) continue
+
+    const status = isInstalled ? chalk.green('✓ installed') : chalk.dim('○ available')
+    const tags = method.tags.map(t => chalk.dim(`#${t}`)).join(' ')
+
+    console.log(`  ${chalk.white(method.id.padEnd(24))} ${status}`)
+    console.log(`  ${chalk.dim(method.description)}`)
+    console.log(`  ${tags}\n`)
+    shown++
+  }
+
+  if (shown === 0 && options.installed) {
+    console.log(chalk.dim('  No methods installed yet.\n'))
+    console.log(chalk.dim(`  Run ${chalk.white('enet install reflex')} to get started.\n`))
+    return
+  }
+
+  if (!options.installed) {
+    console.log(chalk.dim(`  Install: ${chalk.white('enet install <method>')}`))
+    console.log(chalk.dim(`  Example: ${chalk.white('enet install reflex')}\n`))
+  }
+}

package/src/commands/new.js

@@ -0,0 +1,134 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import path from 'path'
+
+export async function newCommand(type, name, options) {
+  const VALID = ['module', 'ui-pack', 'integration']
+  if (!VALID.includes(type)) {
+    console.log(chalk.red(`  ✗ Unknown type: "${type}". Valid: ${VALID.join(', ')}\n`))
+    process.exit(1)
+  }
+
+  const id = name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '')
+  const section = options.section || (type === 'ui-pack' ? 'appearance' : 'modules')
+  const cwd = process.cwd()
+  const modulesDir = await findModulesDir(cwd)
+  const targetDir = path.join(modulesDir, id)
+
+  if (await fs.pathExists(targetDir)) {
+    console.log(chalk.red(`  ✗ Already exists: ${path.relative(cwd, targetDir)}\n`))
+    process.exit(1)
+  }
+
+  const files = buildScaffold(type, id, name, section)
+
+  if (options.dryRun) {
+    console.log(chalk.dim('\n  Files that would be created:\n'))
+    Object.keys(files).forEach(f => console.log(chalk.dim(`  ${path.relative(cwd, path.join(targetDir, f))}`)))
+    console.log()
+    return
+  }
+
+  for (const [filePath, content] of Object.entries(files)) {
+    const full = path.join(targetDir, filePath)
+    await fs.ensureDir(path.dirname(full))
+    await fs.writeFile(full, content)
+  }
+
+  const rel = path.relative(cwd, targetDir)
+  console.log(chalk.green(`\n  ✓ ${type} "${name}" scaffolded\n`))
+  Object.keys(files).forEach(f => console.log(chalk.dim(`  ${rel}/${f}`)))
+  console.log()
+  console.log(chalk.dim('  Next:'))
+  console.log(chalk.dim(`  1. Complete ${chalk.white(`${rel}/manifest.json`)}`))
+  console.log(chalk.dim(`  2. Implement the handlers`))
+  console.log(chalk.dim(`  3. Run ${chalk.white('enet validate')}\n`))
+}
+
+function buildScaffold(type, id, name, section) {
+  const cls = toPascal(id)
+  if (type === 'module') return {
+    'manifest.json': JSON.stringify({
+      id, name, version: '1.0.0', type: 'functional', section,
+      dependencies: [], hooks: {},
+      settings: {
+        enabled: { type: 'boolean', label: 'Enable module', default: true, ui: 'toggle' }
+      },
+      capabilities: [
+        { type: 'view',   label: `${name} List`, data: `${cls}.getAll` },
+        { type: 'metric', label: `Total ${name}`, data: `${cls}.count` }
+      ]
+    }, null, 2),
+    [`handlers/${id}.js`]: `export class ${cls} {
+  constructor(context) { this.ctx = context; this.db = context.db }
+
+  async getAll(ctx, { page = 1, limit = 20 } = {}) {
+    // TODO: implement
+    return []
+  }
+
+  async count(ctx) {
+    // TODO: implement
+    return 0
+  }
+}
+`,
+    'README.md': `# ${name}\n\nDescribe this module.\n`
+  }
+
+  if (type === 'ui-pack') return {
+    'manifest.json': JSON.stringify({
+      id, name, version: '1.0.0', type: 'ui', section: 'appearance',
+      dependencies: [],
+      capabilities: [{
+        type: 'theme', label: `${name} Theme`,
+        variables: { 'primary-color': '#6366f1', 'font-family': 'Inter, sans-serif', 'border-radius': '8px' }
+      }]
+    }, null, 2),
+    'styles/theme.css': `:root {\n  --primary-color: #6366f1;\n  --font-family: Inter, sans-serif;\n  --border-radius: 8px;\n}\n`,
+    'README.md': `# ${name} UI Pack\n\nActivate from Admin Panel → Appearance.\n`
+  }
+
+  if (type === 'integration') return {
+    'manifest.json': JSON.stringify({
+      id, name, version: '1.0.0', type: 'integration', section,
+      dependencies: [], hooks: {},
+      settings: {
+        api_key: { type: 'string', label: 'API Key', default: '', ui: 'text' },
+        enabled: { type: 'boolean', label: 'Enable', default: false, ui: 'toggle' }
+      },
+      capabilities: [
+        { type: 'action', label: 'Test Connection', handler: `${cls}.testConnection` },
+        { type: 'metric', label: 'Status', data: `${cls}.getStatus` }
+      ]
+    }, null, 2),
+    [`handlers/${id}.js`]: `export class ${cls} {
+  constructor(context) { this.ctx = context }
+
+  get apiKey() { return this.ctx.settings.get('api_key') }
+
+  async testConnection(ctx) {
+    if (!this.apiKey) return { success: false, message: 'API key not configured' }
+    // TODO: implement
+    return { success: true, message: 'Connected' }
+  }
+
+  async getStatus(ctx) {
+    return this.ctx.settings.get('enabled') ? 'active' : 'disabled'
+  }
+}
+`,
+    'README.md': `# ${name} Integration\n\nConfigure API Key in Admin Panel → ${section}.\n`
+  }
+}
+
+function toPascal(str) {
+  return str.split('-').map(s => s[0].toUpperCase() + s.slice(1)).join('')
+}
+
+async function findModulesDir(cwd) {
+  for (const dir of ['modules', 'packs', 'src/modules']) {
+    if (await fs.pathExists(path.join(cwd, dir))) return path.join(cwd, dir)
+  }
+  return path.join(cwd, 'modules')
+}

package/src/commands/status.js

@@ -0,0 +1,60 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import path from 'path'
+import ora from 'ora'
+import { getAllMethods } from '../utils/registry.js'
+import { detectAgent, getInstallPath } from '../utils/agent-detector.js'
+
+export async function statusCommand() {
+  const cwd = process.cwd()
+
+  const spinner = ora('Loading...').start()
+  const [methods, agent] = await Promise.all([getAllMethods(), detectAgent()])
+  spinner.stop()
+
+  console.log(chalk.white('  Project Status\n'))
+  console.log(chalk.dim(`  Directory : ${cwd}`))
+  console.log(chalk.dim(`  Agent     : ${chalk.white(agent.name)}\n`))
+
+  console.log(chalk.dim('  Installed methods:\n'))
+
+  let any = false
+  for (const method of methods) {
+    const installPath = getInstallPath(agent, method.id)
+    if (await fs.pathExists(installPath)) {
+      console.log(`  ${chalk.green('✓')} ${chalk.white(method.name)}`)
+      console.log(chalk.dim(`    ${path.relative(cwd, installPath)}\n`))
+      any = true
+    }
+  }
+
+  if (!any) {
+    console.log(chalk.dim(`  None. Run ${chalk.white('enet install reflex')} to get started.\n`))
+    return
+  }
+
+  const hasSchema = await fs.pathExists(path.join(cwd, 'manifest.schema.json'))
+  console.log(`  ${hasSchema ? chalk.green('✓') : chalk.dim('○')} manifest.schema.json`)
+
+  const moduleCount = await countModules(cwd)
+  if (moduleCount > 0) {
+    console.log(`  ${chalk.green('✓')} ${moduleCount} module${moduleCount > 1 ? 's' : ''} found`)
+  }
+
+  console.log()
+  console.log(chalk.dim(`  ${chalk.white('enet validate')}   check all manifests`))
+  console.log(chalk.dim(`  ${chalk.white('enet doctor')}     full health check\n`))
+}
+
+async function countModules(cwd) {
+  let count = 0
+  for (const dir of ['modules', 'packs', 'src/modules']) {
+    const full = path.join(cwd, dir)
+    if (!await fs.pathExists(full)) continue
+    const entries = await fs.readdir(full)
+    for (const e of entries) {
+      if (await fs.pathExists(path.join(full, e, 'manifest.json'))) count++
+    }
+  }
+  return count
+}

package/src/commands/update.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk'
+import ora from 'ora'
+import fs from 'fs-extra'
+import { getAllMethods, getMethod, fetchFromGitHub } from '../utils/registry.js'
+import { detectAgent, getInstallPath } from '../utils/agent-detector.js'
+
+export async function updateCommand(methodId, options) {
+  const spinner = ora('Fetching registry...').start()
+  const [allMethods, agent] = await Promise.all([getAllMethods(), detectAgent()])
+  spinner.stop()
+
+  const targets = methodId
+    ? [(await getMethod(methodId))].filter(Boolean)
+    : allMethods
+
+  if (methodId && targets.length === 0) {
+    console.log(chalk.red(`  ✗ Unknown method: "${methodId}"\n`))
+    process.exit(1)
+  }
+
+  console.log(chalk.white(`\n  Updating methods...\n`))
+
+  let updated = 0, skipped = 0
+
+  for (const method of targets) {
+    const installPath = getInstallPath(agent, method.id)
+    if (!await fs.pathExists(installPath)) { skipped++; continue }
+
+    const s = ora(`Updating ${method.name}...`).start()
+    try {
+      const adapterPath = method.adapters[agent.key] ?? method.adapters.generic
+      const content = await fetchFromGitHub(method.repo, adapterPath)
+      await fs.writeFile(installPath, content)
+      s.succeed(chalk.green(`${method.name} updated`))
+      updated++
+    } catch (err) {
+      s.fail(chalk.yellow(`${method.name} — ${err.message}`))
+    }
+  }
+
+  console.log()
+  if (updated === 0 && skipped > 0) {
+    console.log(chalk.dim(`  No methods installed to update.\n`))
+  } else {
+    console.log(chalk.dim(`  ${updated} updated, ${skipped} not installed\n`))
+  }
+}

package/src/commands/validate.js

@@ -0,0 +1,105 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import path from 'path'
+import Ajv from 'ajv'
+import addFormats from 'ajv-formats'
+
+export async function validateCommand(targetPath, options) {
+  const cwd = process.cwd()
+  const schemaPath = path.join(cwd, 'manifest.schema.json')
+
+  if (!await fs.pathExists(schemaPath)) {
+    console.log(chalk.red('\n  ✗ manifest.schema.json not found'))
+    console.log(chalk.dim(`  Run ${chalk.white('enet install reflex')} to install it.\n`))
+    process.exit(1)
+  }
+
+  const schema = await fs.readJson(schemaPath)
+  const ajv = new Ajv({ allErrors: true })
+  addFormats(ajv)
+  const validate = ajv.compile(schema)
+
+  let manifests = []
+
+  if (targetPath) {
+    const p = path.resolve(cwd, targetPath, 'manifest.json')
+    if (await fs.pathExists(p)) manifests = [p]
+    else { console.log(chalk.red(`\n  ✗ No manifest.json at ${targetPath}\n`)); process.exit(1) }
+  } else {
+    manifests = await findAllManifests(cwd)
+    if (manifests.length === 0) {
+      const local = path.join(cwd, 'manifest.json')
+      if (await fs.pathExists(local)) manifests = [local]
+    }
+  }
+
+  if (manifests.length === 0) {
+    console.log(chalk.dim('\n  No manifest.json files found.'))
+    console.log(chalk.dim(`  Run ${chalk.white('enet init')} to create one.\n`))
+    return
+  }
+
+  console.log(chalk.white(`\n  Validating ${manifests.length} manifest${manifests.length > 1 ? 's' : ''}...\n`))
+
+  let passed = 0, failed = 0
+
+  for (const manifestPath of manifests) {
+    const rel = path.relative(cwd, manifestPath)
+    let data
+    try {
+      data = await fs.readJson(manifestPath)
+    } catch (e) {
+      console.log(`  ${chalk.red('✗')} ${chalk.white(rel)}`)
+      console.log(chalk.red(`    Invalid JSON: ${e.message}\n`))
+      failed++; continue
+    }
+
+    const valid = validate(data)
+    const warnings = semanticChecks(data)
+
+    if (valid) {
+      console.log(`  ${chalk.green('✓')} ${chalk.white(rel)} ${chalk.dim(`— ${data.name} v${data.version}`)}`)
+      warnings.forEach(w => console.log(chalk.dim(`    ⚠ ${w}`)))
+      if (options.strict && warnings.length > 0) failed++
+      else passed++
+    } else {
+      console.log(`  ${chalk.red('✗')} ${chalk.white(rel)} ${chalk.dim(`— ${data.name || 'unknown'}`)}`)
+      validate.errors.forEach(err => {
+        console.log(chalk.red(`    ✗ ${err.instancePath || err.schemaPath}: ${err.message}`))
+      })
+      failed++
+    }
+    console.log()
+  }
+
+  console.log(chalk.dim('  ' + '─'.repeat(40)))
+  if (failed === 0) {
+    console.log(chalk.green(`  ✓ All ${passed} manifest${passed > 1 ? 's' : ''} valid\n`))
+  } else {
+    console.log(chalk.red(`  ✗ ${failed} failed`) + chalk.dim(`, ${passed} passed\n`))
+    process.exit(1)
+  }
+}
+
+function semanticChecks(m) {
+  const w = []
+  if (!m.capabilities?.length) w.push('No capabilities — module invisible in Admin Panel')
+  if (m.settings && Object.keys(m.settings).length === 0) w.push('Empty settings object')
+  const unprotected = (m.capabilities || []).filter(c => c.type === 'action' && !c.permissions?.length)
+  if (unprotected.length) w.push(`${unprotected.length} action(s) without permissions`)
+  return w
+}
+
+async function findAllManifests(cwd) {
+  const results = []
+  for (const dir of ['modules', 'packs', 'src/modules']) {
+    const full = path.join(cwd, dir)
+    if (!await fs.pathExists(full)) continue
+    const entries = await fs.readdir(full)
+    for (const entry of entries) {
+      const p = path.join(full, entry, 'manifest.json')
+      if (await fs.pathExists(p)) results.push(p)
+    }
+  }
+  return results
+}

package/src/index.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+import { program } from 'commander'
+import chalk from 'chalk'
+import { installCommand } from './commands/install.js'
+import { listCommand } from './commands/list.js'
+import { initCommand } from './commands/init.js'
+import { validateCommand } from './commands/validate.js'
+import { newCommand } from './commands/new.js'
+import { updateCommand } from './commands/update.js'
+import { statusCommand } from './commands/status.js'
+import { doctorCommand } from './commands/doctor.js'
+
+const VERSION = '1.0.0'
+
+console.log(chalk.cyan(`\n◆ enet v${VERSION} — exchanet methods manager\n`))
+
+program
+  .name('enet')
+  .description('Install, scaffold and manage exchanet AI coding methods')
+  .version(VERSION)
+
+program
+  .command('install <method>')
+  .description('Install a method into the current project')
+  .option('-a, --agent <agent>', 'Force agent: cursor | windsurf | copilot | generic')
+  .option('-g, --global', 'Install globally to home directory')
+  .action(installCommand)
+
+program
+  .command('list')
+  .alias('ls')
+  .description('List all available methods')
+  .option('--installed', 'Show only installed methods')
+  .action(listCommand)
+
+program
+  .command('init')
+  .description('Interactively create a manifest.json for a new module')
+  .option('-n, --name <name>', 'Module name')
+  .option('-s, --section <section>', 'Admin Panel section')
+  .option('--json', 'Print manifest as JSON without writing to disk')
+  .action(initCommand)
+
+program
+  .command('validate [path]')
+  .description('Validate manifest.json files against the schema')
+  .option('-a, --all', 'Validate all modules recursively')
+  .option('--strict', 'Treat warnings as errors')
+  .action(validateCommand)
+
+program
+  .command('new <type> <name>')
+  .description('Scaffold a new module, ui-pack or integration')
+  .option('-s, --section <section>', 'Admin Panel section')
+  .option('--dry-run', 'Preview files without writing')
+  .action(newCommand)
+
+program
+  .command('update [method]')
+  .description('Update installed methods to latest version')
+  .option('--all', 'Update all installed methods')
+  .action(updateCommand)
+
+program
+  .command('status')
+  .description('Show installed methods and detected agent')
+  .action(statusCommand)
+
+program
+  .command('doctor')
+  .description('Diagnose project setup — manifests, methods, agent config')
+  .action(doctorCommand)
+
+program.parse()

package/src/utils/agent-detector.js

@@ -0,0 +1,56 @@
+import fs from 'fs-extra'
+import path from 'path'
+
+export const AGENTS = {
+  cursor: {
+    name: 'Cursor',
+    signals: ['.cursor'],
+    installDir: '.cursor/rules',
+    filename: 'enet-{id}.md',
+    configNote: 'Rule auto-applies to all files (alwaysApply: true)'
+  },
+  windsurf: {
+    name: 'Windsurf',
+    signals: ['.windsurfrules', '.windsurf'],
+    installDir: '.',
+    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'
+  },
+  generic: {
+    name: 'Generic Agent',
+    signals: [],
+    installDir: '.enet',
+    filename: '{id}.md',
+    configNote: 'Saved to .enet/ — paste contents into your agent\'s context'
+  }
+}
+
+/**
+ * Detects which AI agent is active in the current project.
+ */
+export async function detectAgent(cwd = process.cwd()) {
+  for (const [key, agent] of Object.entries(AGENTS)) {
+    if (key === 'generic') continue
+    for (const signal of agent.signals) {
+      if (await fs.pathExists(path.join(cwd, signal))) {
+        return { key, ...agent }
+      }
+    }
+  }
+  return { key: 'generic', ...AGENTS.generic }
+}
+
+/**
+ * Returns the full install path for a method adapter.
+ */
+export function getInstallPath(agent, methodId, cwd = process.cwd()) {
+  const filename = agent.filename.replace('{id}', methodId)
+  return path.join(cwd, agent.installDir, filename)
+}

package/src/utils/registry.js

@@ -0,0 +1,85 @@
+import fetch from 'node-fetch'
+import fs from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const RAW_BASE   = 'https://raw.githubusercontent.com'
+const REGISTRY_URL = `${RAW_BASE}/exchanet/enet/main/registry.json`
+const CACHE_FILE   = path.join(__dirname, '../../.registry-cache.json')
+const CACHE_TTL_MS = 1000 * 60 * 60 // 1 hour
+
+// ── Registry ──────────────────────────────────────────────────────────────────
+
+/**
+ * Loads the registry from:
+ * 1. Remote GitHub (exchanet/enet/registry.json) — always fresh
+ * 2. Local cache if remote fails — fallback
+ * 3. Bundled registry.json in the package — last resort
+ */
+export async function loadRegistry() {
+  // Try remote first
+  try {
+    const res = await fetch(REGISTRY_URL, { timeout: 5000 })
+    if (res.ok) {
+      const data = await res.json()
+      // Save to cache for offline fallback
+      await fs.writeJson(CACHE_FILE, { ...data, _cachedAt: Date.now() }).catch(() => {})
+      return data
+    }
+  } catch {
+    // Network unavailable — fall through to cache
+  }
+
+  // Try local cache
+  try {
+    if (await fs.pathExists(CACHE_FILE)) {
+      const cached = await fs.readJson(CACHE_FILE)
+      const age = Date.now() - (cached._cachedAt || 0)
+      if (age < CACHE_TTL_MS * 24) { // Accept cache up to 24h when offline
+        return cached
+      }
+    }
+  } catch {
+    // Cache corrupted — fall through to bundled
+  }
+
+  // Fallback to bundled registry.json
+  const bundled = path.join(__dirname, '../../registry.json')
+  return fs.readJson(bundled)
+}
+
+/**
+ * Returns a single method from the registry, or null if not found.
+ */
+export async function getMethod(id) {
+  const registry = await loadRegistry()
+  return registry.methods?.[id] ?? null
+}
+
+/**
+ * Returns all methods from the registry as an array.
+ */
+export async function getAllMethods() {
+  const registry = await loadRegistry()
+  return Object.values(registry.methods ?? {})
+}
+
+// ── GitHub file fetcher ───────────────────────────────────────────────────────
+
+/**
+ * Fetches a raw file from a GitHub repo (main branch).
+ */
+export async function fetchFromGitHub(repo, filePath) {
+  const url = `${RAW_BASE}/${repo}/main/${filePath}`
+  const res = await fetch(url)
+
+  if (!res.ok) {
+    throw new Error(
+      `Could not fetch ${filePath} from ${repo} (HTTP ${res.status})\n` +
+      `  URL: ${url}`
+    )
+  }
+
+  return res.text()
+}