@axiomatic-labs/claudeflow 2.3.8 → 2.4.0

package/bin/cli.js

@@ -1,164 +1,46 @@
 #!/usr/bin/env node
 
-// npm shim: downloads the Go binary if needed, then delegates all commands to it.
+// npx entry point: handles install, update, and version commands directly.
+// No Go binary — downloads ZIP and extracts skill files to disk.
 
-const { spawn } = require('child_process');
 const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const https = require('https');
-
-const OWNER = 'axiomatic-labs';
-const REPO = 'claudeflow-cli';
-const BIN_DIR = path.join(os.homedir(), '.claudeflow', 'bin');
-const isWindows = os.platform() === 'win32';
-const BIN_PATH = path.join(BIN_DIR, isWindows ? 'claudeflow.exe' : 'claudeflow');
-const VERSION_PATH = path.join(os.homedir(), '.claudeflow', 'binary-version');
-
-// Detect platform: darwin-arm64, darwin-amd64, linux-amd64, windows-amd64
-function getPlatformBinary() {
-  const platform = os.platform(); // darwin, linux, win32
-  const arch = os.arch(); // arm64, x64
-  const goArch = arch === 'x64' ? 'amd64' : arch;
-  const goPlatform = platform === 'win32' ? 'windows' : platform;
-  const ext = platform === 'win32' ? '.exe' : '';
-  return `claudeflow-${goPlatform}-${goArch}${ext}`;
-}
-
-function fetchUrl(url, headers = {}) {
-  return new Promise((resolve, reject) => {
-    const mod = url.startsWith('https') ? https : require('http');
-    mod.get(url, { headers: { 'User-Agent': 'claudeflow-cli', ...headers } }, (res) => {
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        return fetchUrl(res.headers.location, {}).then(resolve).catch(reject);
-      }
-      if (res.statusCode !== 200) {
-        let body = '';
-        res.on('data', (d) => body += d);
-        res.on('end', () => reject(new Error(`HTTP ${res.statusCode}: ${body.slice(0, 200)}`)));
-        return;
-      }
-      const chunks = [];
-      res.on('data', (d) => chunks.push(d));
-      res.on('end', () => resolve(Buffer.concat(chunks)));
-    }).on('error', reject);
-  });
-}
-
-async function downloadBinary(token) {
-  const ui = require('../lib/ui.js');
-
-  ui.step('Fetching latest release...');
-
-  const releaseData = await fetchUrl(
-    `https://api.github.com/repos/${OWNER}/${REPO}/releases/latest`,
-    { Authorization: `Bearer ${token}`, Accept: 'application/vnd.github+json' }
-  );
-  const release = JSON.parse(releaseData.toString());
-
-  const binaryName = getPlatformBinary();
-  const asset = release.assets.find((a) => a.name === binaryName);
-  if (!asset) {
-    ui.error(`No binary found for your platform: ${binaryName}`);
-    ui.info(`Available: ${release.assets.map((a) => a.name).join(', ')}`);
-    process.exit(1);
-  }
-
-  ui.step(`Downloading ${release.tag_name} (${binaryName})...`);
-
-  const binaryData = await fetchUrl(
-    `https://api.github.com/repos/${OWNER}/${REPO}/releases/assets/${asset.id}`,
-    { Authorization: `Bearer ${token}`, Accept: 'application/octet-stream' }
-  );
-
-  fs.mkdirSync(BIN_DIR, { recursive: true });
-  fs.writeFileSync(BIN_PATH, binaryData, { mode: 0o755 });
-
-  // Ad-hoc sign on macOS (required by recent macOS versions)
-  if (os.platform() === 'darwin') {
-    const { execSync } = require('child_process');
-    try {
-      execSync(`codesign --force --sign - "${BIN_PATH}"`, { stdio: 'pipe' });
-    } catch {}
-  }
-
-  fs.writeFileSync(VERSION_PATH, release.tag_name + '\n');
-
-  ui.success(`Claudeflow ${release.tag_name} installed to ~/.claudeflow/bin/`);
-  return release.tag_name;
-}
-
-async function ensureBinary() {
-  if (!fs.existsSync(BIN_PATH)) {
-    // First run — interactive auth + download
-    const ui = require('../lib/ui.js');
-    const { requireAuth } = require('../lib/auth.js');
-    ui.banner();
-    ui.step('First run — downloading Claudeflow binary...');
-
-    const token = await requireAuth();
-    try {
-      await downloadBinary(token);
-    } catch (err) {
-      ui.error('Could not download Claudeflow binary.');
-      ui.info('Ensure your token has the "repo" scope and can access axiomatic-labs/claudeflow-cli.');
-      process.exit(1);
-    }
-    return;
-  }
-
-  // Binary exists — check for updates silently
-  try {
-    const { getGitHubToken } = require('../lib/auth.js');
-    const token = getGitHubToken();
-    if (!token) return; // No cached token, skip check
-
-    const installed = fs.existsSync(VERSION_PATH)
-      ? fs.readFileSync(VERSION_PATH, 'utf-8').trim()
-      : null;
-
-    const releaseData = await fetchUrl(
-      `https://api.github.com/repos/${OWNER}/${REPO}/releases/latest`,
-      { Authorization: `Bearer ${token}`, Accept: 'application/vnd.github+json' }
-    );
-    const release = JSON.parse(releaseData.toString());
-    const latest = release.tag_name;
-
-    if (installed && installed === latest) return; // Already up to date
-
-    const ui = require('../lib/ui.js');
-    ui.banner();
-    ui.step(`Updating binary to ${latest}...`);
-    await downloadBinary(token);
-  } catch {
-    // Network/API error — skip silently, use existing binary
-  }
-}
 
 async function main() {
   const args = process.argv.slice(2);
-
-  // These commands need the Go binary
-  await ensureBinary();
-
-  // Delegate to Go binary with transparent I/O
-  const child = spawn(BIN_PATH, args, {
-    stdio: 'inherit',
-    env: process.env,
-  });
-
-  child.on('exit', (code) => {
-    process.exit(code || 0);
-  });
-
-  child.on('error', (err) => {
-    if (err.code === 'ENOENT') {
-      console.error('Claudeflow binary not found. Try reinstalling: npx @axiomatic-labs/claudeflow');
-    } else {
-      console.error(`Failed to start claudeflow: ${err.message}`);
+  const command = args[0] || 'install';
+
+  switch (command) {
+    case 'install':
+    case 'init': {
+      const init = require('../lib/init.js');
+      await init();
+      break;
     }
-    process.exit(1);
-  });
+    case 'update': {
+      const update = require('../lib/update.js');
+      await update();
+      break;
+    }
+    case 'version':
+    case '--version':
+    case '-v': {
+      const version = require('../lib/version.js');
+      await version();
+      break;
+    }
+    default: {
+      const ui = require('../lib/ui.js');
+      ui.banner();
+      console.log('  Usage: npx @axiomatic-labs/claudeflow [command]');
+      console.log('');
+      console.log('  Commands:');
+      console.log(`    ${ui.CYAN}install${ui.RESET}   Download and extract Claudeflow (default)`);
+      console.log(`    ${ui.CYAN}update${ui.RESET}    Re-download and update template files`);
+      console.log(`    ${ui.CYAN}version${ui.RESET}   Show version info`);
+      console.log('');
+      break;
+    }
+  }
 }
 
 main().catch((err) => {

package/lib/init.js

@@ -43,7 +43,7 @@ async function run() {
 
   try {
     ui.step('Extracting template files...');
-    execSync(`unzip -o "${tmpZip}" ".claude/*" -d "${process.cwd()}"`, { stdio: 'pipe' });
+    execSync(`unzip -o "${tmpZip}" -d "${process.cwd()}"`, { stdio: 'pipe' });
   } finally {
     fs.unlinkSync(tmpZip);
   }

package/lib/update.js

@@ -0,0 +1,160 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { requireAuth } = require('./auth.js');
+const { getLatestRelease, downloadReleaseAsset } = require('./download.js');
+const { writeLocalVersion, readLocalVersion } = require('./version.js');
+const ui = require('./ui.js');
+
+// Template skills that ship with the ZIP — only these get overwritten.
+// User-generated skills (from /setup, /update) are preserved.
+const TEMPLATE_SKILLS = new Set([
+  'claudeflow-init',
+  'claudeflow-update',
+  'claudeflow-design-tokens',
+  'claudeflow-create-ui',
+  'claudeflow-checkpoints',
+]);
+
+async function run() {
+  const current = readLocalVersion();
+
+  ui.banner(current);
+
+  if (!current) {
+    ui.warn('Claudeflow is not installed. Run: npx @axiomatic-labs/claudeflow');
+    console.log('');
+    process.exit(1);
+  }
+
+  ui.step('Authenticating with GitHub...');
+  const token = await requireAuth();
+
+  ui.step('Fetching latest release...');
+  const release = await getLatestRelease(token);
+  const version = release.tag_name;
+
+  // Find the ZIP asset
+  const asset = release.assets.find((a) => a.name.endsWith('.zip'));
+  if (!asset) {
+    ui.error('No ZIP asset found in the latest release.');
+    process.exit(1);
+  }
+
+  ui.step(`Downloading ${version}...`);
+  const zipBuffer = await downloadReleaseAsset(asset, token);
+
+  // Write ZIP to temp file and extract to a temp directory first
+  const tmpZip = path.join(require('os').tmpdir(), `claudeflow-update-${Date.now()}.zip`);
+  const tmpExtract = path.join(require('os').tmpdir(), `claudeflow-extract-${Date.now()}`);
+  fs.writeFileSync(tmpZip, zipBuffer);
+  fs.mkdirSync(tmpExtract, { recursive: true });
+
+  try {
+    ui.step('Extracting template files...');
+    execSync(`unzip -o "${tmpZip}" -d "${tmpExtract}"`, { stdio: 'pipe' });
+
+    const cwd = process.cwd();
+    const srcClaude = path.join(tmpExtract, '.claude');
+
+    // Copy settings.json
+    const srcSettings = path.join(srcClaude, 'settings.json');
+    const dstSettings = path.join(cwd, '.claude', 'settings.json');
+    if (fs.existsSync(srcSettings)) {
+      fs.copyFileSync(srcSettings, dstSettings);
+    }
+
+    // Copy template skills only (preserve user-generated skills)
+    const srcSkills = path.join(srcClaude, 'skills');
+    const dstSkills = path.join(cwd, '.claude', 'skills');
+    if (fs.existsSync(srcSkills)) {
+      fs.mkdirSync(dstSkills, { recursive: true });
+      const skillDirs = fs.readdirSync(srcSkills, { withFileTypes: true });
+      for (const entry of skillDirs) {
+        if (entry.isDirectory() && TEMPLATE_SKILLS.has(entry.name)) {
+          copyDirSync(path.join(srcSkills, entry.name), path.join(dstSkills, entry.name));
+        }
+      }
+    }
+
+    // Copy all hooks
+    const srcHooks = path.join(srcClaude, 'hooks');
+    const dstHooks = path.join(cwd, '.claude', 'hooks');
+    if (fs.existsSync(srcHooks)) {
+      copyDirSync(srcHooks, dstHooks);
+    }
+
+    // Copy all docs
+    const srcDocs = path.join(srcClaude, 'docs');
+    const dstDocs = path.join(cwd, '.claude', 'docs');
+    if (fs.existsSync(srcDocs)) {
+      copyDirSync(srcDocs, dstDocs);
+    }
+
+    // Ensure .claude/tmp exists
+    fs.mkdirSync(path.join(cwd, '.claude', 'tmp'), { recursive: true });
+
+    // NOTE: CLAUDE.md is NOT overwritten — it gets generated dynamically by /setup and /update skills
+
+    // Copy .mcp.json to project root (empty — no MCP server needed)
+    const srcMcp = path.join(tmpExtract, '.mcp.json');
+    const dstMcp = path.join(cwd, '.mcp.json');
+    if (fs.existsSync(srcMcp)) {
+      fs.copyFileSync(srcMcp, dstMcp);
+    }
+
+    // Write version file
+    writeLocalVersion(version);
+
+  } finally {
+    fs.unlinkSync(tmpZip);
+    fs.rmSync(tmpExtract, { recursive: true, force: true });
+  }
+
+  // Count updated items
+  const skillsDir = path.join(process.cwd(), '.claude', 'skills');
+  let skillCount = 0;
+  try {
+    skillCount = fs.readdirSync(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).length;
+  } catch {}
+
+  const hooksDir = path.join(process.cwd(), '.claude', 'hooks');
+  let hookCount = 0;
+  try {
+    hookCount = fs.readdirSync(hooksDir, { withFileTypes: true }).filter((e) => e.isDirectory()).length;
+  } catch {}
+
+  const docsDir = path.join(process.cwd(), '.claude', 'docs');
+  let docCount = 0;
+  try {
+    docCount = fs.readdirSync(docsDir).filter((f) => !f.startsWith('.')).length;
+  } catch {}
+
+  console.log('');
+  ui.success(`${skillCount} skills (${TEMPLATE_SKILLS.size} template updated, user skills preserved)`);
+  ui.success(`${hookCount} hooks updated`);
+  ui.success(`${docCount} docs updated`);
+
+  if (current === version) {
+    ui.done(`Claudeflow ${version} reinstalled.`);
+  } else {
+    ui.done(`Claudeflow updated: ${current} → ${version}`);
+  }
+}
+
+// Recursively copy a directory, creating parents as needed
+function copyDirSync(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const dstPath = path.join(dst, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, dstPath);
+    } else {
+      fs.copyFileSync(srcPath, dstPath);
+    }
+  }
+}
+
+module.exports = run;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiomatic-labs/claudeflow",
-  "version": "2.3.8",
+  "version": "2.4.0",
   "description": "Claudeflow — AI-powered development toolkit for Claude Code. Skills, agents, hooks, and quality gates that ship production apps.",
   "bin": {
     "claudeflow": "./bin/cli.js"