@exchanet/enet 1.0.9 → 1.0.10

package/package.json

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

package/src/commands/install.js

@@ -20,6 +20,11 @@ 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
   let targetAgents = []

package/src/commands/update.js

@@ -1,12 +1,15 @@
 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'
+import path from 'path'
+import readline from 'readline'
+import { getAllMethods, getMethod, 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, agent] = await Promise.all([getAllMethods(), detectAgent()])
+  const [allMethods, detectedAgents] = await Promise.all([getAllMethods(), detectSystemAgents()])
   spinner.stop()
 
   const targets = methodId
@@ -18,30 +21,203 @@ export async function updateCommand(methodId, options) {
     process.exit(1)
   }
 
-  console.log(chalk.white(`\n  Updating methods...\n`))
+  console.log(chalk.bold('\n  ◆ enet update\n'))
 
-  let updated = 0, skipped = 0
+  let totalUpdated = 0, totalAdded = 0, totalSkipped = 0
 
   for (const method of targets) {
-    const installPath = getInstallPath(agent, method.id)
-    if (!await fs.pathExists(installPath)) { skipped++; continue }
+    const record = await readInstallRecord(method.id)
 
-    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}`))
+    if (!record || record.agents.length === 0) {
+      totalSkipped++
+      console.log(chalk.dim(`  ${method.name} — not installed, skipping`))
+      continue
+    }
+
+    console.log(chalk.white(`  ${method.name}`))
+    console.log(chalk.dim(`  Installed for: ${record.agents.join(', ')}\n`))
+
+    // Agents already installed for this method
+    const installedAgents = record.agents
+      .map(key => AGENTS[key] ? { key, ...AGENTS[key] } : null)
+      .filter(Boolean)
+
+    // Agents newly detected 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
+    if (!options.addOnly) {
+      for (const agent of installedAgents) {
+        const ok = await updateOneAdapter(method, agent, options)
+        if (ok) totalUpdated++
+      }
+    }
+
+    // 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`))
+
+      let agentsToAdd = []
+      if (options.all) {
+        agentsToAdd = newAgents
+        console.log(chalk.dim(`  Adding all: ${newAgents.map(a => a.name).join(', ')}\n`))
+      } else {
+        agentsToAdd = await checkboxSelectNew(newAgents, method)
+      }
+
+      for (const agent of agentsToAdd) {
+        const ok = await installForAgent(method, agent, options, true)
+        if (ok) { totalAdded++; record.agents.push(agent.key) }
+      }
+
+      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`))
     }
   }
 
+  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`))
+  if (totalSkipped > 0) console.log(chalk.dim(`    ${totalSkipped} method${totalSkipped !== 1 ? 's' : ''} not installed, skipped`))
+  if (totalUpdated === 0 && totalAdded === 0 && totalSkipped === 0) {
+    console.log(chalk.dim('  Everything is up to date.'))
+  }
   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`))
+}
+
+async function updateOneAdapter(method, agent, options = {}) {
+  const isGlobal   = options.global || false
+  const adapterKey = method.adapters[agent.key] ? agent.key : 'generic'
+  const adapterPath = method.adapters[adapterKey]
+
+  if (!adapterPath) {
+    console.log(chalk.dim(`  ${agent.name} — no adapter in registry, skipping`))
+    return false
+  }
+
+  const installPath = getInstallPath(agent, method.id, { global: isGlobal })
+  const exists  = await fs.pathExists(installPath)
+  const action  = exists ? 'Updating' : 'Restoring'
+  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))
+
+    if (agent.key === 'windsurf' && exists) {
+      const existing = await fs.readFile(installPath, 'utf8')
+      if (existing.includes(method.name)) {
+        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}`)
+      }
+    } else {
+      await fs.writeFile(installPath, content)
+    }
+
+    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
   }
 }
+
+async function checkboxSelectNew(newAgents, method) {
+  const items = newAgents.map(a => ({
+    agent: a, checked: true, usesGeneric: !method.adapters[a.key]
+  }))
+
+  return new Promise((resolve) => {
+    let cursor = 0
+    const lineCount = () => items.length + 4
+
+    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`)
+      })
+      process.stdout.write('\n')
+      process.stdout.write(chalk.dim('  ↑↓ navigate · Space toggle · A all · Enter confirm\n\n'))
+    }
+
+    render()
+
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+    if (process.stdin.isTTY) process.stdin.setRawMode(true)
+    process.stdin.resume()
+
+    process.stdin.on('data', (key) => {
+      const k = key.toString()
+      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 === '\r' || k === '\n') {
+        if (process.stdin.isTTY) process.stdin.setRawMode(false)
+        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)
+      }
+    })
+  })
+}
+```
+
+---
+
+## 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/utils/registry.js

@@ -83,3 +83,31 @@ export async function fetchFromGitHub(repo, filePath) {
 
   return res.text()
 }
+
+// ── Install state ─────────────────────────────────────────────────────────────
+// Stored in <project>/.enet/installed.json
+// { "pdca-t": { "agents": ["cursor", "claudecode"], "version": "3.0.0", "updatedAt": "..." } }
+
+function getInstallRecordFile() {
+  return path.join(process.cwd(), '.enet', 'installed.json')
+}
+
+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 }
+}
+
+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() }
+    await fs.writeJson(file, data, { spaces: 2 })
+  } catch { /* non-fatal */ }
+}