@exchanet/enet 1.0.11 → 1.0.12

package/package.json

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

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/registry.js

@@ -1,43 +1,60 @@
-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 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 {
-    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()
       await fs.writeJson(CACHE_FILE, { ...data, _cachedAt: Date.now() }).catch(() => {})
       return data
     }
-  } catch { /* network unavailable */ }
+  } catch {
+    // Network unavailable — fall through to 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) return cached
+      if (age < CACHE_TTL_MS * 24) {
+        return cached
+      }
     }
-  } catch { /* cache corrupted */ }
+  } catch {
+    // Cache corrupted — fall through to bundled
+  }
 
   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 ?? {})
@@ -45,22 +62,27 @@ export async function getAllMethods() {
 
 // ── 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()
 }
 
 // ── Install state ─────────────────────────────────────────────────────────────
 //
 // Tracks which agents have each method installed.
-// Stored in <project>/.enet/installed.json
+// Stored in .enet/installed.json in the project root.
 //
 // Format:
 // {
@@ -68,15 +90,19 @@ export async function fetchFromGitHub(repo, filePath) {
 //     "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')
 }
 
 /**
- * Returns the install record for a single method, or null if never installed.
+ * 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 {
@@ -90,22 +116,25 @@ export async function readInstallRecord(methodId) {
 }
 
 /**
- * Writes the install record for a single method.
- * Merges with existing records — other methods are never touched.
+ * 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,
+      agents: record.agents,
+      version: record.version ?? null,
       updatedAt: new Date().toISOString()
     }
+
     await fs.writeJson(file, data, { spaces: 2 })
   } catch {
     // Non-fatal — install works correctly even if state cannot be saved