@exchanet/enet 1.0.10 → 1.0.12

package/package.json

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

package/src/commands/install.js

@@ -4,7 +4,7 @@ import fs from 'fs-extra'
 import path from 'path'
 import readline from 'readline'
 import { detectSystemAgents, getInstallPath, AGENTS } from '../utils/agent-detector.js'
-import { getMethod, fetchFromGitHub } from '../utils/registry.js'
+import { getMethod, fetchFromGitHub, readInstallRecord, writeInstallRecord } from '../utils/registry.js'
 
 export async function installCommand(methodId, options) {
   // 1. Load method from registry
@@ -20,17 +20,20 @@ export async function installCommand(methodId, options) {
 
   console.log(chalk.bold(`\n  ◆ ${method.name}`))
   console.log(chalk.dim(`  ${method.description}\n`))
-    const record = await readInstallRecord(methodId)
-    const alreadyInstalled = new Set(record?.agents ?? [])
-    if (alreadyInstalled.size > 0) {
-      console.log(chalk.dim(`  Already installed for: ${[...alreadyInstalled].join(', ')}\n`))
-    }
 
-  // 2. Determine target agents
+  // 2. Read existing install record — know what is already installed
+  const record = await readInstallRecord(methodId)
+  const alreadyInstalled = new Set(record?.agents ?? [])
+
+  if (alreadyInstalled.size > 0) {
+    console.log(chalk.dim(`  Already installed for: ${[...alreadyInstalled].join(', ')}\n`))
+  }
+
+  // 3. Determine target agents
   let targetAgents = []
 
   if (options.agent) {
-    // --agent flag: skip detection, install for this specific agent only
+    // --agent flag: bypass detection and checkbox entirely
     if (!AGENTS[options.agent]) {
       console.log(chalk.red(`  ✗ Unknown agent: "${options.agent}"`))
       console.log(chalk.dim(`  Valid: ${Object.keys(AGENTS).filter(k => k !== 'generic').join(', ')}\n`))
@@ -39,23 +42,20 @@ export async function installCommand(methodId, options) {
     targetAgents = [{ key: options.agent, ...AGENTS[options.agent] }]
 
   } else {
-    // 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(`  Use ${chalk.white('--agent <n>')} to force an agent.`))
       console.log(chalk.dim(`  Valid: ${Object.keys(AGENTS).filter(k => k !== 'generic').join(', ')}\n`))
       process.exit(1)
     }
 
-    // 3. Show checkbox selection — always, even with 1 agent detected
-    //    This is the core UX fix: user always chooses, never surprised
     if (options.all) {
-      // --all flag skips the prompt
       targetAgents = detected
     } else {
-      targetAgents = await checkboxSelect(detected, method)
+      // Always show checkbox — even with 1 agent, even on re-run
+      targetAgents = await checkboxSelect(detected, method, alreadyInstalled)
     }
 
     if (targetAgents.length === 0) {
@@ -66,66 +66,74 @@ export async function installCommand(methodId, options) {
 
   console.log()
 
-  // 4. Install for each selected agent
+  // 4. Install each selected agent
+  const newlyInstalled = []
   let schemaInstalled = false
+
   for (const agent of targetAgents) {
-    await installForAgent(method, agent, options, schemaInstalled)
+    const ok = await installForAgent(method, agent, options, schemaInstalled)
     schemaInstalled = true
+    if (ok) newlyInstalled.push(agent.key)
   }
 
+  // 5. Persist updated install record
+  const updatedAgents = [...new Set([...alreadyInstalled, ...newlyInstalled])]
+  await writeInstallRecord(methodId, { agents: updatedAgents, version: method.version })
+
   printHints(methodId)
 }
 
 // ─────────────────────────────────────────────────────────────────
 // Checkbox selection UI
+//
+// Shows all detected agents with tags:
+//   — installed   already present on disk for this method
+//   — new         detected but never installed for this method
 // ─────────────────────────────────────────────────────────────────
 
-async function checkboxSelect(detected, method) {
-  // Build list: detected agents that have an adapter in this method come first,
-  // then show unavailable ones as disabled so user knows what exists
-  const available = detected.filter(a => method.adapters[a.key] || method.adapters['generic'])
+async function checkboxSelect(detected, method, alreadyInstalled = new Set()) {
+  const available   = detected.filter(a =>  method.adapters[a.key] || method.adapters['generic'])
   const unavailable = detected.filter(a => !method.adapters[a.key] && !method.adapters['generic'])
 
   if (available.length === 0) {
     console.log(chalk.yellow('  ⚠ No adapters available for your detected agents.'))
-    console.log(chalk.dim(`  Available adapters in this method: ${Object.keys(method.adapters).join(', ')}\n`))
+    console.log(chalk.dim(`  Adapters in this method: ${Object.keys(method.adapters).join(', ')}\n`))
     process.exit(1)
   }
 
-  // Initial state: all available agents pre-checked
   const items = available.map(a => ({
-    agent: a,
-    checked: true,
+    agent:       a,
+    checked:     true,
+    installed:   alreadyInstalled.has(a.key),
     usesGeneric: !method.adapters[a.key]
   }))
 
-  console.log(chalk.white('  Agents detected on your system:\n'))
+  console.log(chalk.white('  Select adapters to install:\n'))
 
   return new Promise((resolve) => {
     let cursor = 0
 
+    const lineCount = () => items.length + (unavailable.length > 0 ? 3 : 2) + 2
+
     const render = () => {
-      // Move cursor up to redraw (after first render)
-      const lines = items.length + 6
-      if (render.drawn) process.stdout.write(`\x1B[${lines}A`)
+      if (render.drawn) process.stdout.write(`\x1B[${lineCount()}A`)
       render.drawn = true
 
       items.forEach((item, i) => {
         const isCursor = i === cursor
-        const box = item.checked ? chalk.green('[✓]') : chalk.dim('[ ]')
-        const arrow = isCursor ? chalk.cyan(' ❯ ') : '   '
-        const name = isCursor ? chalk.white(item.agent.name) : chalk.dim(item.agent.name)
-        const tag = item.usesGeneric ? chalk.dim(' (generic adapter)') : ''
-        process.stdout.write(`${arrow}${box} ${name}${tag}\n`)
+        const box     = item.checked     ? chalk.green('[✓]')           : chalk.dim('[ ]')
+        const arrow   = isCursor         ? chalk.cyan(' ❯ ')            : '   '
+        const name    = isCursor         ? chalk.white(item.agent.name) : chalk.dim(item.agent.name)
+        const status  = item.installed   ? chalk.dim(' — installed')    : chalk.yellow(' — new')
+        const generic = item.usesGeneric ? chalk.dim(' (generic adapter)') : ''
+        process.stdout.write(`${arrow}${box} ${name}${status}${generic}\n`)
       })
 
       if (unavailable.length > 0) {
-        process.stdout.write(chalk.dim(`\n  Not available for: ${unavailable.map(a => a.name).join(', ')}\n`))
-      } else {
-        process.stdout.write('\n')
+        process.stdout.write(chalk.dim(`\n  No adapter for: ${unavailable.map(a => a.name).join(', ')}\n`))
       }
-
-      process.stdout.write(chalk.dim('  ↑↓ navigate · Space toggle · A select all · Enter confirm\n\n'))
+      process.stdout.write('\n')
+      process.stdout.write(chalk.dim('  ↑↓ navigate · Space toggle · A all · Enter confirm · Ctrl+C cancel\n\n'))
     }
 
     render()
@@ -136,28 +144,25 @@ async function checkboxSelect(detected, method) {
 
     process.stdin.on('data', (key) => {
       const k = key.toString()
-
-      if (k === '\u001b[A') {                      // arrow up
-        cursor = (cursor - 1 + items.length) % items.length
-        render()
-      } else if (k === '\u001b[B') {               // arrow down
-        cursor = (cursor + 1) % items.length
-        render()
-      } else if (k === ' ') {                      // space: toggle current
-        items[cursor].checked = !items[cursor].checked
+      if      (k === '\u001b[A') { cursor = (cursor - 1 + items.length) % items.length; render() }
+      else if (k === '\u001b[B') { cursor = (cursor + 1) % items.length; render() }
+      else if (k === ' ')        { items[cursor].checked = !items[cursor].checked; render() }
+      else if (k === 'a' || k === 'A') {
+        const all = items.every(i => i.checked)
+        items.forEach(i => { i.checked = !all })
         render()
-      } else if (k === 'a' || k === 'A') {         // A: toggle all
-        const allChecked = items.every(i => i.checked)
-        items.forEach(i => { i.checked = !allChecked })
-        render()
-      } else if (k === '\r' || k === '\n') {       // Enter: confirm
+      }
+      else if (k === '\r' || k === '\n') {
         if (process.stdin.isTTY) process.stdin.setRawMode(false)
         process.stdin.pause()
         rl.close()
         const selected = items.filter(i => i.checked).map(i => i.agent)
-        console.log(chalk.dim(`\n  Installing for: ${selected.map(a => a.name).join(', ')}\n`))
+        if (selected.length > 0) {
+          console.log(chalk.dim(`\n  Installing for: ${selected.map(a => a.name).join(', ')}\n`))
+        }
         resolve(selected)
-      } else if (k === '\u0003') {                 // Ctrl+C
+      }
+      else if (k === '\u0003') {
         if (process.stdin.isTTY) process.stdin.setRawMode(false)
         process.stdin.pause()
         rl.close()
@@ -170,41 +175,44 @@ async function checkboxSelect(detected, method) {
 
 // ─────────────────────────────────────────────────────────────────
 // Install for one agent
+// Exported so update.js can reuse it without duplication
+// Returns true on success, false on failure/skip
 // ─────────────────────────────────────────────────────────────────
 
-async function installForAgent(method, agent, options, skipExtras = false) {
-  const isGlobal = options.global || false
-
-  // Use the agent-specific adapter if available, fall back to generic
-  const adapterKey = method.adapters[agent.key] ? agent.key : 'generic'
+export 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 (!adapterPath) {
     console.log(chalk.yellow(`  ⚠ ${agent.name} — no adapter found, skipping`))
-    return
+    return false
   }
 
   if (isGlobal && !agent.globalInstallDir) {
     console.log(chalk.yellow(`  ⚠ ${agent.name} — global install not supported, skipping`))
-    return
+    return false
   }
 
-  const spinner = ora(`Installing for ${agent.name}${isGlobal ? ' (global)' : ''}...`).start()
+  const spinner = ora(`${agent.name}${isGlobal ? ' (global)' : ''}...`).start()
 
   try {
-    const content = await fetchFromGitHub(method.repo, adapterPath)
+    const content     = await fetchFromGitHub(method.repo, adapterPath)
     const installPath = getInstallPath(agent, method.id, { global: isGlobal })
 
     await fs.ensureDir(path.dirname(installPath))
 
-    // Windsurf: append to .windsurfrules instead of overwriting
+    // Windsurf: append to .windsurfrules — replace existing section if already present
     if (agent.key === 'windsurf' && await fs.pathExists(installPath)) {
       const existing = await fs.readFile(installPath, 'utf8')
       if (existing.includes(method.name)) {
-        spinner.warn(chalk.yellow(`${agent.name} — already installed`))
-        return
+        const marker = '\n\n---\n\n'
+        const idx    = existing.indexOf(method.name)
+        const before = existing.substring(0, existing.lastIndexOf(marker, idx) + marker.length)
+        await fs.writeFile(installPath, before + content)
+      } else {
+        await fs.appendFile(installPath, `\n\n---\n\n${content}`)
       }
-      await fs.appendFile(installPath, `\n\n---\n\n${content}`)
     } else {
       await fs.writeFile(installPath, content)
     }
@@ -215,24 +223,25 @@ async function installForAgent(method, agent, options, skipExtras = false) {
 
   } catch (err) {
     spinner.fail(chalk.red(`${agent.name} — ${err.message}`))
-    return
+    return false
   }
 
-  // Download extras (schema, etc.) — only once across all agents
+  // Extras (schema, manifests…) — downloaded once across all agents
   if (!skipExtras && method.extras) {
     for (const [key, filePath] of Object.entries(method.extras)) {
-      const extraSpinner = ora(`Fetching ${key}...`).start()
+      const s = 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)}`))
+        const content = await fetchFromGitHub(method.repo, filePath)
+        await fs.writeFile(path.join(process.cwd(), path.basename(filePath)), content)
+        s.succeed(chalk.dim(`${key} → ${path.basename(filePath)}`))
       } catch {
-        extraSpinner.warn(chalk.dim(`${key} not available (non-critical)`))
+        s.warn(chalk.dim(`${key} not available (non-critical)`))
       }
     }
     console.log()
   }
+
+  return true
 }
 
 // ─────────────────────────────────────────────────────────────────
@@ -246,7 +255,7 @@ function printHints(methodId) {
     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 new module <n>')}   scaffold your first module`))
     console.log(chalk.dim(`  ${chalk.white('enet validate')}             check manifests at any time\n`))
   }
   if (methodId === 'pdca-t') {

package/src/commands/update.js

@@ -3,13 +3,16 @@ import ora from 'ora'
 import fs from 'fs-extra'
 import path from 'path'
 import readline from 'readline'
-import { getAllMethods, getMethod, readInstallRecord, writeInstallRecord } from '../utils/registry.js'
+import { getAllMethods, getMethod, fetchFromGitHub, readInstallRecord, writeInstallRecord } from '../utils/registry.js'
 import { detectSystemAgents, getInstallPath, AGENTS } from '../utils/agent-detector.js'
 import { installForAgent } from './install.js'
 
 export async function updateCommand(methodId, options) {
   const spinner = ora('Fetching registry...').start()
-  const [allMethods, detectedAgents] = await Promise.all([getAllMethods(), detectSystemAgents()])
+  const [allMethods, detectedAgents] = await Promise.all([
+    getAllMethods(),
+    detectSystemAgents()
+  ])
   spinner.stop()
 
   const targets = methodId
@@ -28,6 +31,7 @@ export async function updateCommand(methodId, options) {
   for (const method of targets) {
     const record = await readInstallRecord(method.id)
 
+    // Skip methods not installed at all
     if (!record || record.agents.length === 0) {
       totalSkipped++
       console.log(chalk.dim(`  ${method.name} — not installed, skipping`))
@@ -42,13 +46,13 @@ export async function updateCommand(methodId, options) {
       .map(key => AGENTS[key] ? { key, ...AGENTS[key] } : null)
       .filter(Boolean)
 
-    // Agents newly detected but not yet installed for this method
+    // Agents newly detected on system but NOT yet installed for this method
     const newAgents = detectedAgents.filter(a =>
       !record.agents.includes(a.key) &&
       (method.adapters[a.key] || method.adapters['generic'])
     )
 
-    // 1. Update already-installed adapters
+    // ── 1. Update already-installed adapters ────────────────────
     if (!options.addOnly) {
       for (const agent of installedAgents) {
         const ok = await updateOneAdapter(method, agent, options)
@@ -56,7 +60,7 @@ export async function updateCommand(methodId, options) {
       }
     }
 
-    // 2. Offer to add newly detected agents
+    // ── 2. Offer to add newly detected agents ───────────────────
     if (newAgents.length > 0 && !options.updateOnly) {
       console.log(chalk.yellow(`\n  New agents detected since last install:\n`))
 
@@ -70,15 +74,21 @@ export async function updateCommand(methodId, options) {
 
       for (const agent of agentsToAdd) {
         const ok = await installForAgent(method, agent, options, true)
-        if (ok) { totalAdded++; record.agents.push(agent.key) }
+        if (ok) {
+          totalAdded++
+          record.agents.push(agent.key)
+        }
       }
 
+      // Save updated record with newly added agents
       await writeInstallRecord(method.id, { agents: record.agents, version: method.version })
+
     } else if (newAgents.length === 0 && !options.addOnly) {
       console.log(chalk.dim(`  No new agents detected.\n`))
     }
   }
 
+  // ── Summary ──────────────────────────────────────────────────
   console.log(chalk.dim('  ─────────────────────────────'))
   if (totalUpdated > 0) console.log(chalk.green(`  ✓ ${totalUpdated} adapter${totalUpdated !== 1 ? 's' : ''} updated`))
   if (totalAdded > 0)   console.log(chalk.green(`  ✓ ${totalAdded} new adapter${totalAdded !== 1 ? 's' : ''} installed`))
@@ -89,9 +99,14 @@ export async function updateCommand(methodId, options) {
   console.log()
 }
 
+// ─────────────────────────────────────────────────────────────────
+// Update a single already-installed adapter
+// Re-downloads from GitHub and overwrites the local file
+// ─────────────────────────────────────────────────────────────────
+
 async function updateOneAdapter(method, agent, options = {}) {
-  const isGlobal   = options.global || false
-  const adapterKey = method.adapters[agent.key] ? agent.key : 'generic'
+  const isGlobal    = options.global || false
+  const adapterKey  = method.adapters[agent.key] ? agent.key : 'generic'
   const adapterPath = method.adapters[adapterKey]
 
   if (!adapterPath) {
@@ -105,10 +120,10 @@ async function updateOneAdapter(method, agent, options = {}) {
   const s = ora(`${action} ${agent.name}...`).start()
 
   try {
-    const { fetchFromGitHub } = await import('../utils/registry.js')
     const content = await fetchFromGitHub(method.repo, adapterPath)
     await fs.ensureDir(path.dirname(installPath))
 
+    // Windsurf: replace existing section, don't append duplicates
     if (agent.key === 'windsurf' && exists) {
       const existing = await fs.readFile(installPath, 'utf8')
       if (existing.includes(method.name)) {
@@ -126,15 +141,22 @@ async function updateOneAdapter(method, agent, options = {}) {
     s.succeed(chalk.green(`${agent.name} — ${action.toLowerCase()}d`))
     console.log(chalk.dim(`  → ${installPath}\n`))
     return true
+
   } catch (err) {
     s.fail(chalk.red(`${agent.name} — ${err.message}`))
     return false
   }
 }
 
+// ─────────────────────────────────────────────────────────────────
+// Checkbox for new agents only (shown during update)
+// ─────────────────────────────────────────────────────────────────
+
 async function checkboxSelectNew(newAgents, method) {
   const items = newAgents.map(a => ({
-    agent: a, checked: true, usesGeneric: !method.adapters[a.key]
+    agent:       a,
+    checked:     true,
+    usesGeneric: !method.adapters[a.key]
   }))
 
   return new Promise((resolve) => {
@@ -144,16 +166,18 @@ async function checkboxSelectNew(newAgents, method) {
     const render = () => {
       if (render.drawn) process.stdout.write(`\x1B[${lineCount()}A`)
       render.drawn = true
+
       items.forEach((item, i) => {
         const isCursor = i === cursor
-        const box   = item.checked ? chalk.green('[✓]') : chalk.dim('[ ]')
-        const arrow = isCursor     ? chalk.cyan(' ❯ ')  : '   '
-        const name  = isCursor     ? chalk.white(item.agent.name) : chalk.dim(item.agent.name)
-        const tag   = item.usesGeneric ? chalk.dim(' (generic adapter)') : ''
-        process.stdout.write(`${arrow}${box} ${name}${tag}\n`)
+        const box     = item.checked     ? chalk.green('[✓]')           : chalk.dim('[ ]')
+        const arrow   = isCursor         ? chalk.cyan(' ❯ ')            : '   '
+        const name    = isCursor         ? chalk.white(item.agent.name) : chalk.dim(item.agent.name)
+        const generic = item.usesGeneric ? chalk.dim(' (generic adapter)') : ''
+        process.stdout.write(`${arrow}${box} ${name}${generic}\n`)
       })
+
       process.stdout.write('\n')
-      process.stdout.write(chalk.dim('  ↑↓ navigate · Space toggle · A all · Enter confirm\n\n'))
+      process.stdout.write(chalk.dim('  ↑↓ navigate · Space toggle · A all · Enter confirm · Ctrl+C cancel\n\n'))
     }
 
     render()
@@ -169,55 +193,22 @@ async function checkboxSelectNew(newAgents, method) {
       else if (k === ' ')        { items[cursor].checked = !items[cursor].checked; render() }
       else if (k === 'a' || k === 'A') {
         const all = items.every(i => i.checked)
-        items.forEach(i => { i.checked = !all }); render()
+        items.forEach(i => { i.checked = !all })
+        render()
       }
       else if (k === '\r' || k === '\n') {
         if (process.stdin.isTTY) process.stdin.setRawMode(false)
-        process.stdin.pause(); rl.close()
+        process.stdin.pause()
+        rl.close()
         resolve(items.filter(i => i.checked).map(i => i.agent))
       }
       else if (k === '\u0003') {
         if (process.stdin.isTTY) process.stdin.setRawMode(false)
-        process.stdin.pause(); rl.close()
-        console.log('\n'); process.exit(0)
+        process.stdin.pause()
+        rl.close()
+        console.log('\n')
+        process.exit(0)
       }
     })
   })
 }
-```
-
----
-
-## Dónde van estos archivos en el repo
-```
-exchanet/enet/
-├── src/
-│   ├── commands/
-│   │   ├── install.js   ← cambios A, B, C + checkboxSelect con alreadyInstalled
-│   │   └── update.js    ← reemplazar completo
-│   └── utils/
-│       └── registry.js  ← añadir al final las 2 funciones nuevas
-```
-
-Una vez subidos, el flujo queda así:
-```
-$ enet install pdca-t        # primera vez
-  Already installed for: copilot   ← lee .enet/installed.json
-
-  Select adapters to install:
-   ❯ [✓] Cursor              — new
-     [✓] Antigravity          — new
-     [✓] Claude Code          — new
-     [✓] GitHub Copilot       — installed   ← sabe que ya está
-
-$ enet update pdca-t         # después de instalar Windsurf
-  Method PDCA-T
-  Installed for: cursor, claudecode
-
-  Updating Cursor...          ✓  ← re-descarga adapter
-  Updating Claude Code...     ✓
-
-  New agents detected since last install:
-   ❯ [✓] Windsurf             — new
-
-  → instala Windsurf y actualiza installed.json

package/src/index.js

@@ -2,6 +2,7 @@
 
 import { program } from 'commander'
 import chalk from 'chalk'
+import { createRequire } from 'module'
 import { installCommand } from './commands/install.js'
 import { listCommand } from './commands/list.js'
 import { initCommand } from './commands/init.js'
@@ -11,10 +12,48 @@ import { updateCommand } from './commands/update.js'
 import { statusCommand } from './commands/status.js'
 import { doctorCommand } from './commands/doctor.js'
 
-const VERSION = '1.0.0'
+// Read version from package.json — single source of truth
+const require = createRequire(import.meta.url)
+const pkg = require('../package.json')
+const VERSION = pkg.version
+
+// ── Version check ─────────────────────────────────────────────────────────────
+// Runs in background — never blocks the command, never crashes if offline
+
+async function checkForUpdate() {
+  try {
+    const res = await fetch(
+      'https://registry.npmjs.org/@exchanet/enet/latest',
+      { signal: AbortSignal.timeout(3000) }
+    )
+    if (!res.ok) return
+    const data = await res.json()
+    const latest = data.version
+    if (latest && latest !== VERSION) {
+      console.log(
+        chalk.yellow('  ⚠ Update available: ') +
+        chalk.dim(`v${VERSION}`) +
+        chalk.white(' → ') +
+        chalk.green(`v${latest}`) + '\n' +
+        chalk.dim('  Run ') +
+        chalk.white('npm install -g @exchanet/enet') +
+        chalk.dim(' to update.\n')
+      )
+    }
+  } catch {
+    // Offline or npm unreachable — silently skip
+  }
+}
+
+// Fire in background without await — command runs immediately
+checkForUpdate()
+
+// ── Header ────────────────────────────────────────────────────────────────────
 
 console.log(chalk.cyan(`\n◆ enet v${VERSION} — exchanet methods manager\n`))
 
+// ── Commands ──────────────────────────────────────────────────────────────────
+
 program
   .name('enet')
   .description('Install, scaffold and manage exchanet AI coding methods')
@@ -23,8 +62,9 @@ program
 program
   .command('install <method>')
   .description('Install a method into the current project')
-  .option('-a, --agent <agent>', 'Force agent: cursor | windsurf | copilot | generic')
+  .option('-a, --agent <agent>', 'Force agent: cursor | windsurf | antigravity | claudecode | copilot | generic')
   .option('-g, --global', 'Install globally to home directory')
+  .option('--all', 'Install for all detected agents without prompting')
   .action(installCommand)
 
 program
@@ -58,8 +98,11 @@ program
 
 program
   .command('update [method]')
-  .description('Update installed methods to latest version')
-  .option('--all', 'Update all installed methods')
+  .description('Update installed methods and add adapters for new agents')
+  .option('--all', 'Add all new agents without prompting')
+  .option('--add-only', 'Only add new agents, skip re-downloading existing')
+  .option('--update-only', 'Only re-download existing, skip new agent prompt')
+  .option('-g, --global', 'Update global install')
   .action(updateCommand)
 
 program

package/src/utils/{agent-detector.js → agent_detector.js}

@@ -9,9 +9,9 @@ export const AGENTS = {
     name: 'Cursor',
     systemSignals: [
       path.join(HOME, '.cursor'),
-      path.join(HOME, 'Library', 'Application Support', 'Cursor'),
-      path.join(HOME, 'AppData', 'Roaming', 'Cursor'),
-      path.join(HOME, '.config', 'Cursor'),
+      path.join(HOME, 'Library', 'Application Support', 'Cursor'),   // macOS
+      path.join(HOME, 'AppData', 'Roaming', 'Cursor'),               // Windows
+      path.join(HOME, '.config', 'Cursor'),                          // Linux
     ],
     projectSignals: ['.cursor/rules', '.cursor'],
     projectInstallDir: '.cursor/rules',
@@ -24,8 +24,8 @@ export const AGENTS = {
     name: 'Windsurf',
     systemSignals: [
       path.join(HOME, '.codeium', 'windsurf'),
-      path.join(HOME, 'Library', 'Application Support', 'Windsurf'),
-      path.join(HOME, 'AppData', 'Roaming', 'Windsurf'),
+      path.join(HOME, 'Library', 'Application Support', 'Windsurf'), // macOS
+      path.join(HOME, 'AppData', 'Roaming', 'Windsurf'),             // Windows
     ],
     projectSignals: ['.windsurfrules', '.windsurf'],
     projectInstallDir: '.',
@@ -39,11 +39,13 @@ export const AGENTS = {
     name: 'Antigravity (Google)',
     systemSignals: [
       path.join(HOME, '.gemini', 'antigravity'),
-      path.join(HOME, 'Library', 'Application Support', 'Google', 'Antigravity'),
-      path.join(HOME, 'AppData', 'Roaming', 'Google', 'Antigravity'),
+      path.join(HOME, 'Library', 'Application Support', 'Google', 'Antigravity'), // macOS
+      path.join(HOME, 'AppData', 'Roaming', 'Google', 'Antigravity'),             // Windows
     ],
     projectSignals: ['.agent/rules', '.agent'],
     projectInstallDir: '.agent/rules',
+    // globalInstallDir is a base — getInstallPath() resolves the full path dynamically:
+    // ~/.gemini/antigravity/skills/method-{id}/SKILL.md
     globalInstallDir: path.join(HOME, '.gemini', 'antigravity', 'skills'),
     globalFilename: 'SKILL.md',
     filename: 'enet-{id}.md',
@@ -65,13 +67,16 @@ export const AGENTS = {
 
   copilot: {
     name: 'GitHub Copilot',
+    // Copilot is a VS Code extension — detect by checking the extensions folder
+    // for a github.copilot-* subfolder, not just the presence of .vscode/
     systemSignals: [
-      path.join(HOME, '.vscode', 'extensions'),
-      path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'extensions'),
-      path.join(HOME, 'AppData', 'Roaming', 'Code', 'User', 'extensions'),
-      path.join(HOME, '.vscode-server', 'extensions'),
+      path.join(HOME, '.vscode', 'extensions'),                                         // Linux / Windows
+      path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'extensions'), // macOS
+      path.join(HOME, 'AppData', 'Roaming', 'Code', 'User', 'extensions'),             // Windows alt
+      path.join(HOME, '.vscode-server', 'extensions'),                                  // remote / SSH
     ],
     systemSignalFilter: (signalPath) => {
+      // Only return true if a github.copilot extension folder exists inside
       try {
         const entries = fs.readdirSync(signalPath)
         return entries.some(e => e.toLowerCase().startsWith('github.copilot'))
@@ -81,7 +86,7 @@ export const AGENTS = {
     },
     projectSignals: ['.github/copilot-instructions.md'],
     projectInstallDir: '.github',
-    globalInstallDir: null,
+    globalInstallDir: null, // Copilot has no global rules path
     filename: 'copilot-instructions.md',
     configNote: 'Written to .github/copilot-instructions.md'
   },
@@ -93,10 +98,19 @@ export const AGENTS = {
     projectInstallDir: '.enet',
     globalInstallDir: null,
     filename: '{id}.md',
-    configNote: "Saved to .enet/ — paste contents into your agent's context"
+    configNote: 'Saved to .enet/ — paste contents into your agent\'s context'
   }
 }
 
+// ─────────────────────────────────────────────────────────────────
+// Detection
+// ─────────────────────────────────────────────────────────────────
+
+/**
+ * Detects ALL agents installed on the system by checking known global paths.
+ * Uses systemSignalFilter for agents that share directories with other software
+ * (e.g. Copilot shares VS Code's extensions folder).
+ */
 export async function detectSystemAgents() {
   const found = []
   for (const [key, agent] of Object.entries(AGENTS)) {
@@ -109,7 +123,7 @@ export async function detectSystemAgents() {
           found.push({ key, ...agent })
           break
         }
-        continue
+        continue // signal dir exists but filter didn't match — try next signal path
       }
       found.push({ key, ...agent })
       break
@@ -118,6 +132,9 @@ export async function detectSystemAgents() {
   return found
 }
 
+/**
+ * Detects ALL agents present in the current project folder.
+ */
 export async function detectProjectAgents(cwd = process.cwd()) {
   const found = []
   for (const [key, agent] of Object.entries(AGENTS)) {
@@ -132,16 +149,33 @@ export async function detectProjectAgents(cwd = process.cwd()) {
   return found
 }
 
+/**
+ * Returns the first detected agent (legacy — used by status/doctor).
+ */
 export async function detectAgent(cwd = process.cwd()) {
   const agents = await detectProjectAgents(cwd)
   return agents[0] ?? { key: 'generic', ...AGENTS.generic }
 }
 
+// ─────────────────────────────────────────────────────────────────
+// Path resolution
+// ─────────────────────────────────────────────────────────────────
+
+/**
+ * Returns the resolved install path for a given agent + method.
+ *
+ * Special cases:
+ *  - antigravity global → ~/.gemini/antigravity/skills/method-{id}/SKILL.md
+ *    Each method gets its own subfolder (not a shared file).
+ *  - windsurf global    → ~/.codeium/windsurf/memories/global_rules.md
+ *  - claudecode global  → ~/.claude/CLAUDE.md
+ */
 export function getInstallPath(agent, methodId, { global = false, cwd = process.cwd() } = {}) {
   if (global) {
-    if (!agent.globalInstallDir) return null
+    if (!agent.globalInstallDir) return null // agent doesn't support global install
 
     if (agent.key === 'antigravity') {
+      // Dynamic subfolder per method: skills/method-{id}/SKILL.md
       return path.join(agent.globalInstallDir, `method-${methodId}`, 'SKILL.md')
     }
 
@@ -149,6 +183,7 @@ export function getInstallPath(agent, methodId, { global = false, cwd = process.
     return path.join(agent.globalInstallDir, filename)
   }
 
+  // Project-level install
   const filename = agent.filename.replace('{id}', methodId)
   return path.join(cwd, agent.projectInstallDir, filename)
 }

package/src/utils/registry.js

@@ -1,4 +1,3 @@
-import fetch from 'node-fetch'
 import fs from 'fs-extra'
 import path from 'path'
 import { fileURLToPath } from 'url'
@@ -18,12 +17,10 @@ const CACHE_TTL_MS = 1000 * 60 * 60 // 1 hour
  * 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 })
+    const res = await fetch(REGISTRY_URL, { signal: AbortSignal.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
     }
@@ -31,12 +28,11 @@ export async function loadRegistry() {
     // 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
+      if (age < CACHE_TTL_MS * 24) {
         return cached
       }
     }
@@ -44,7 +40,6 @@ export async function loadRegistry() {
     // Cache corrupted — fall through to bundled
   }
 
-  // Fallback to bundled registry.json
   const bundled = path.join(__dirname, '../../registry.json')
   return fs.readJson(bundled)
 }
@@ -85,29 +80,63 @@ export async function fetchFromGitHub(repo, filePath) {
 }
 
 // ── Install state ─────────────────────────────────────────────────────────────
-// Stored in <project>/.enet/installed.json
-// { "pdca-t": { "agents": ["cursor", "claudecode"], "version": "3.0.0", "updatedAt": "..." } }
+//
+// Tracks which agents have each method installed.
+// Stored in .enet/installed.json in the project root.
+//
+// Format:
+// {
+//   "pdca-t": {
+//     "agents": ["cursor", "claudecode", "antigravity"],
+//     "version": "3.0.0",
+//     "updatedAt": "2025-03-01T10:00:00.000Z"
+//   },
+//   "modular-design": { ... }
+// }
 
 function getInstallRecordFile() {
+  // Resolve relative to cwd so it works in any project
   return path.join(process.cwd(), '.enet', 'installed.json')
 }
 
+/**
+ * Reads the install record for a single method.
+ * Returns { agents: ['cursor', ...], version: '3.0.0', updatedAt: '...' }
+ * or null if the method has never been installed.
+ */
 export async function readInstallRecord(methodId) {
   try {
     const file = getInstallRecordFile()
     if (!await fs.pathExists(file)) return null
     const data = await fs.readJson(file)
     return data[methodId] ?? null
-  } catch { return null }
+  } catch {
+    return null
+  }
 }
 
+/**
+ * Writes (or updates) the install record for a single method.
+ * Merges with existing records — other methods are not touched.
+ */
 export async function writeInstallRecord(methodId, record) {
   try {
     const file = getInstallRecordFile()
     await fs.ensureDir(path.dirname(file))
+
     let data = {}
-    if (await fs.pathExists(file)) data = await fs.readJson(file).catch(() => ({}))
-    data[methodId] = { agents: record.agents, version: record.version ?? null, updatedAt: new Date().toISOString() }
+    if (await fs.pathExists(file)) {
+      data = await fs.readJson(file).catch(() => ({}))
+    }
+
+    data[methodId] = {
+      agents: record.agents,
+      version: record.version ?? null,
+      updatedAt: new Date().toISOString()
+    }
+
     await fs.writeJson(file, data, { spaces: 2 })
-  } catch { /* non-fatal */ }
-}
+  } catch {
+    // Non-fatal — install works correctly even if state cannot be saved
+  }
+}