@axiomatic-labs/claudeflow 2.0.0

package/bin/cli.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+const command = process.argv[2];
+
+switch (command) {
+  case 'init':
+    require('../lib/init.js')();
+    break;
+  case 'update':
+    require('../lib/update.js')();
+    break;
+  case 'version':
+    require('../lib/version.js')();
+    break;
+  case '--version':
+  case '-v':
+    console.log(`claudeflow v${require('../package.json').version}`);
+    break;
+  case '--help':
+  case '-h':
+  case undefined: {
+    const ui = require('../lib/ui.js');
+    ui.banner();
+    console.log(`  ${ui.BOLD}Usage:${ui.RESET}`);
+    console.log(`    claudeflow ${ui.CYAN}init${ui.RESET}      Install the latest template files`);
+    console.log(`    claudeflow ${ui.CYAN}update${ui.RESET}    Update templates to latest version`);
+    console.log(`    claudeflow ${ui.CYAN}version${ui.RESET}   Show version info`);
+    console.log('');
+    console.log(`  ${ui.BOLD}Options:${ui.RESET}`);
+    console.log(`    --version, -v   Show CLI version`);
+    console.log(`    --help, -h      Show this help`);
+    console.log('');
+    break;
+  }
+  default:
+    console.error(`Unknown command: ${command}`);
+    console.error('Run "claudeflow --help" for usage.');
+    process.exit(1);
+}

package/lib/auth.js

@@ -0,0 +1,32 @@
+const { execSync } = require('child_process');
+
+function getGitHubToken() {
+  // Try gh CLI first
+  try {
+    const token = execSync('gh auth token', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    if (token) return token;
+  } catch {}
+
+  // Fall back to GITHUB_TOKEN env var
+  if (process.env.GITHUB_TOKEN) {
+    return process.env.GITHUB_TOKEN;
+  }
+
+  return null;
+}
+
+function requireAuth() {
+  const token = getGitHubToken();
+  if (!token) {
+    console.error('GitHub authentication required.\n');
+    console.error('Option 1: Install the GitHub CLI and authenticate:');
+    console.error('  brew install gh && gh auth login\n');
+    console.error('Option 2: Set a GitHub Personal Access Token:');
+    console.error('  export GITHUB_TOKEN=ghp_your_token_here\n');
+    console.error('The token needs read access to axiomatic-labs/axiomatic-cli releases.');
+    process.exit(1);
+  }
+  return token;
+}
+
+module.exports = { getGitHubToken, requireAuth };

package/lib/download.js

@@ -0,0 +1,99 @@
+const https = require('https');
+const { execSync } = require('child_process');
+
+const OWNER = 'axiomatic-labs';
+const REPO = 'axiomatic-cli';
+
+function githubApi(path, token) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'api.github.com',
+      path,
+      headers: {
+        'User-Agent': 'claudeflow-cli',
+        'Authorization': `Bearer ${token}`,
+        'Accept': 'application/vnd.github+json',
+      },
+    };
+
+    https.get(options, (res) => {
+      // Follow redirects
+      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(`GitHub API ${res.statusCode}: ${body}`)));
+        return;
+      }
+
+      const chunks = [];
+      res.on('data', (d) => chunks.push(d));
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(Buffer.concat(chunks).toString()));
+        } catch (e) {
+          reject(e);
+        }
+      });
+    }).on('error', reject);
+  });
+}
+
+function fetchUrl(url) {
+  return new Promise((resolve, reject) => {
+    const mod = url.startsWith('https') ? https : require('http');
+    mod.get(url, { headers: { 'User-Agent': 'claudeflow-cli' } }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return fetchUrl(res.headers.location).then(resolve).catch(reject);
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+      }
+      const chunks = [];
+      res.on('data', (d) => chunks.push(d));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+    }).on('error', reject);
+  });
+}
+
+async function getLatestRelease(token) {
+  return githubApi(`/repos/${OWNER}/${REPO}/releases/latest`, token);
+}
+
+async function downloadReleaseAsset(asset, token) {
+  // Use the GitHub API URL with Accept header for binary
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'api.github.com',
+      path: `/repos/${OWNER}/${REPO}/releases/assets/${asset.id}`,
+      headers: {
+        'User-Agent': 'claudeflow-cli',
+        'Authorization': `Bearer ${token}`,
+        'Accept': 'application/octet-stream',
+      },
+    };
+
+    https.get(options, (res) => {
+      // GitHub redirects to a CDN URL for the actual binary
+      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(`Asset download failed ${res.statusCode}: ${body}`)));
+        return;
+      }
+
+      const chunks = [];
+      res.on('data', (d) => chunks.push(d));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+    }).on('error', reject);
+  });
+}
+
+module.exports = { getLatestRelease, downloadReleaseAsset, OWNER, REPO };

package/lib/init.js

@@ -0,0 +1,136 @@
+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 } = require('./version.js');
+const ui = require('./ui.js');
+
+async function run() {
+  // Check if already initialized
+  const versionFile = path.join(process.cwd(), '.claude', '.claudeflow-version');
+  if (fs.existsSync(versionFile)) {
+    const current = fs.readFileSync(versionFile, 'utf-8').trim();
+    ui.banner(current);
+    ui.warn(`Already initialized at ${current}.`);
+    ui.info('Run: claudeflow update');
+    console.log('');
+    process.exit(1);
+  }
+
+  ui.banner();
+
+  ui.step('Authenticating with GitHub...');
+  const token = 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
+  const tmpZip = path.join(require('os').tmpdir(), `claudeflow-${Date.now()}.zip`);
+  fs.writeFileSync(tmpZip, zipBuffer);
+
+  try {
+    ui.step('Extracting template files...');
+    execSync(`unzip -o "${tmpZip}" ".claude/*" "CLAUDE.md" -d "${process.cwd()}"`, { stdio: 'pipe' });
+  } finally {
+    fs.unlinkSync(tmpZip);
+  }
+
+  // Ensure .claude/tmp exists
+  fs.mkdirSync(path.join(process.cwd(), '.claude', 'tmp'), { recursive: true });
+
+  // Write version file
+  writeLocalVersion(version);
+
+  // Count installed 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 installed`);
+  ui.success(`${hookCount} hooks installed`);
+  ui.success(`${docCount} docs installed`);
+
+  ui.done(`Claudeflow ${version} installed.`);
+
+  // Detect project type: greenfield, single-stack, or multi-stack
+  const MANIFESTS = ['package.json', 'pyproject.toml', 'Gemfile', 'go.mod', 'Cargo.toml', 'composer.json'];
+  const SKIP_DIRS = new Set(['node_modules', 'vendor', '__pycache__', 'dist', 'build', '.next', '.nuxt', '.output', '.claude']);
+
+  const rootHasManifest = MANIFESTS.some((f) => fs.existsSync(path.join(process.cwd(), f)));
+
+  // Scan first-level subdirs for manifests (multi-stack detection)
+  const stackDirs = [];
+  try {
+    const entries = fs.readdirSync(process.cwd(), { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith('.') || SKIP_DIRS.has(entry.name)) continue;
+      if (MANIFESTS.some((f) => fs.existsSync(path.join(process.cwd(), entry.name, f)))) {
+        stackDirs.push(entry.name);
+      }
+    }
+  } catch {}
+
+  const isMultiStack = stackDirs.length > 1 || (rootHasManifest && stackDirs.length > 0);
+  const isGreenfield = !rootHasManifest && stackDirs.length === 0;
+
+  console.log(`  ${ui.BOLD}Getting started:${ui.RESET}`);
+  console.log('');
+  console.log(`  1. Run ${ui.CYAN}claude${ui.RESET} to start Claude Code`);
+
+  if (isGreenfield) {
+    console.log(`  2. Type ${ui.CYAN}/setup${ui.RESET} to scaffold your project`);
+    console.log('');
+    console.log(`     ${ui.DIM}Claudeflow will ask what you want to build, research${ui.RESET}`);
+    console.log(`     ${ui.DIM}the best stack, and generate project-specific skills.${ui.RESET}`);
+  } else if (isMultiStack) {
+    console.log(`  2. Type ${ui.CYAN}/update${ui.RESET} to detect your stacks and generate project-specific skills`);
+    console.log('');
+    ui.info(`Multi-stack project detected: ${stackDirs.join(', ')}${rootHasManifest ? ' + root' : ''}`);
+    console.log('');
+    console.log(`  ${ui.BOLD}After setup:${ui.RESET}`);
+    console.log(`  ${ui.DIM}Just describe what you want — Claudeflow handles the rest.${ui.RESET}`);
+  } else {
+    // Single-stack existing project
+    console.log(`  2. Type ${ui.CYAN}/update${ui.RESET} to detect your stack and generate project-specific skills`);
+    console.log(`  3. Tell Claude what you want — it handles the rest`);
+  }
+
+  console.log('');
+  console.log(`  ${ui.BOLD}Commands:${ui.RESET}`);
+  console.log(`  ${ui.CYAN}/setup${ui.RESET}    ${ui.DIM}Scaffold a new project (greenfield)${ui.RESET}`);
+  console.log(`  ${ui.CYAN}/update${ui.RESET}   ${ui.DIM}Detect stack and generate skills for existing project${ui.RESET}`);
+  console.log(`  ${ui.CYAN}/sdd${ui.RESET}      ${ui.DIM}Generate a feature spec (Spec-Driven Development)${ui.RESET}`);
+  console.log('');
+  console.log(`  ${ui.DIM}Docs: https://claudeflow.dev${ui.RESET}`);
+  console.log('');
+}
+
+module.exports = run;

package/lib/manifest.js

@@ -0,0 +1,38 @@
+// Canonical list of template-managed files — mirrors build-zip.sh.
+// Only these files are managed by init/update. Everything else is user-generated.
+
+// Directory prefixes: any file under these paths is template-managed.
+const TEMPLATE_PREFIXES = [
+  '.claude/skills/claudeflow/',
+  '.claude/skills/claudeflow-init/',
+  '.claude/skills/claudeflow-update/',
+  '.claude/skills/sdd/',
+  '.claude/docs/',
+  '.claude/hooks/',
+];
+
+// Exact file paths that are template-managed.
+const TEMPLATE_FILES = [
+  'CLAUDE.md',
+  '.claude/settings.json',
+  '.claude/agents/example-agent.md',
+  '.claude/rules/example-rules.md',
+];
+
+// Check if a path from the ZIP is a template file.
+function isTemplatePath(relativePath) {
+  // Exact match
+  if (TEMPLATE_FILES.includes(relativePath)) return true;
+
+  // Prefix match (directory-based)
+  for (const prefix of TEMPLATE_PREFIXES) {
+    if (relativePath.startsWith(prefix)) return true;
+  }
+
+  // .claudeflow-version is also managed
+  if (relativePath === '.claude/.claudeflow-version') return true;
+
+  return false;
+}
+
+module.exports = { TEMPLATE_PREFIXES, TEMPLATE_FILES, isTemplatePath };

package/lib/ui.js

@@ -0,0 +1,53 @@
+// Branding and UI helpers for the Claudeflow CLI.
+
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const WHITE = '\x1b[97m';
+const MAGENTA = '\x1b[35m';
+
+function banner(version) {
+  console.log('');
+  console.log(`${DIM}  ╔═══════════════════════════════════════╗${RESET}`);
+  console.log(`${DIM}  ║                                       ║${RESET}`);
+  console.log(`${DIM}  ║${RESET}     ${MAGENTA}${BOLD}◆${RESET}  ${WHITE}${BOLD}C L A U D E F L O W${RESET}        ${DIM}║${RESET}`);
+  console.log(`${DIM}  ║${RESET}        ${DIM}AI-Powered Development${RESET}       ${DIM}║${RESET}`);
+  console.log(`${DIM}  ║                                       ║${RESET}`);
+  console.log(`${DIM}  ╚═══════════════════════════════════════╝${RESET}`);
+  if (version) {
+    console.log(`${DIM}                  ${version}${RESET}`);
+  }
+  console.log('');
+}
+
+function step(msg) {
+  console.log(`  ${DIM}...${RESET} ${msg}`);
+}
+
+function success(msg) {
+  console.log(`  ${GREEN}✓${RESET} ${msg}`);
+}
+
+function warn(msg) {
+  console.log(`  ${YELLOW}!${RESET} ${msg}`);
+}
+
+function error(msg) {
+  console.error(`  ${RED}✗${RESET} ${msg}`);
+}
+
+function info(msg) {
+  console.log(`  ${CYAN}i${RESET} ${msg}`);
+}
+
+function done(msg) {
+  console.log('');
+  console.log(`  ${GREEN}${BOLD}${msg}${RESET}`);
+  console.log('');
+}
+
+module.exports = { banner, step, success, warn, error, info, done, BOLD, DIM, RESET, GREEN, YELLOW, CYAN, RED, WHITE, MAGENTA };

package/lib/update.js

@@ -0,0 +1,101 @@
+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 { readLocalVersion, writeLocalVersion } = require('./version.js');
+const { isTemplatePath } = require('./manifest.js');
+const ui = require('./ui.js');
+
+async function run() {
+  const current = readLocalVersion();
+  if (!current) {
+    ui.banner();
+    ui.error('Not initialized. Run: claudeflow init');
+    console.log('');
+    process.exit(1);
+  }
+
+  ui.banner(current);
+
+  ui.step('Authenticating with GitHub...');
+  const token = requireAuth();
+
+  ui.step('Checking for updates...');
+  const release = await getLatestRelease(token);
+  const latest = release.tag_name;
+
+  if (current === latest) {
+    ui.success(`Already up to date (${current}).`);
+    console.log('');
+    return;
+  }
+
+  ui.info(`${current} ${ui.DIM}->${ui.RESET} ${ui.BOLD}${latest}${ui.RESET}`);
+
+  // 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 ${latest}...`);
+  const zipBuffer = await downloadReleaseAsset(asset, token);
+
+  // Write ZIP to temp file
+  const tmpZip = path.join(require('os').tmpdir(), `claudeflow-${Date.now()}.zip`);
+  const tmpDir = path.join(require('os').tmpdir(), `claudeflow-extract-${Date.now()}`);
+  fs.writeFileSync(tmpZip, zipBuffer);
+
+  try {
+    // Extract to temp directory first
+    fs.mkdirSync(tmpDir, { recursive: true });
+    execSync(`unzip -o "${tmpZip}" -d "${tmpDir}"`, { stdio: 'pipe' });
+
+    ui.step('Updating template files...');
+
+    // Copy only template files
+    const updated = [];
+    copyTemplateFiles(tmpDir, process.cwd(), '', updated);
+
+    // Write version file
+    writeLocalVersion(latest);
+
+    console.log('');
+    const skills = updated.filter((f) => f.includes('/skills/')).length;
+    const hooks = updated.filter((f) => f.includes('/hooks/')).length;
+    const docs = updated.filter((f) => f.includes('/docs/')).length;
+    const other = updated.length - skills - hooks - docs;
+
+    if (skills) ui.success(`${skills} skill files updated`);
+    if (hooks) ui.success(`${hooks} hook files updated`);
+    if (docs) ui.success(`${docs} doc files updated`);
+    if (other) ui.success(`${other} other files updated`);
+
+    ui.done(`Updated to ${latest}.`);
+    ui.info('Generated skills/agents/rules are preserved.');
+    console.log('');
+  } finally {
+    fs.unlinkSync(tmpZip);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+function copyTemplateFiles(srcDir, destDir, prefix, updated) {
+  const entries = fs.readdirSync(path.join(srcDir, prefix), { withFileTypes: true });
+  for (const entry of entries) {
+    const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      copyTemplateFiles(srcDir, destDir, relative, updated);
+    } else if (isTemplatePath(relative)) {
+      const src = path.join(srcDir, relative);
+      const dest = path.join(destDir, relative);
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.copyFileSync(src, dest);
+      updated.push(relative);
+    }
+  }
+}
+
+module.exports = run;

package/lib/version.js

@@ -0,0 +1,63 @@
+const fs = require('fs');
+const path = require('path');
+const { getGitHubToken } = require('./auth.js');
+const { getLatestRelease } = require('./download.js');
+const ui = require('./ui.js');
+
+const VERSION_FILE = path.join(process.cwd(), '.claude', '.claudeflow-version');
+
+function readLocalVersion() {
+  try {
+    return fs.readFileSync(VERSION_FILE, 'utf-8').trim();
+  } catch {
+    return null;
+  }
+}
+
+function writeLocalVersion(version) {
+  const dir = path.dirname(VERSION_FILE);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(VERSION_FILE, version + '\n');
+}
+
+async function run() {
+  const local = readLocalVersion();
+
+  ui.banner(local);
+
+  const cliVersion = require('../package.json').version;
+  ui.info(`CLI version: v${cliVersion}`);
+
+  if (local) {
+    ui.info(`Installed:   ${local}`);
+  } else {
+    ui.warn('Not installed. Run: claudeflow init');
+  }
+
+  const token = getGitHubToken();
+  if (!token) {
+    ui.warn('Authenticate with GitHub to check for updates.');
+    console.log('');
+    return;
+  }
+
+  try {
+    const release = await getLatestRelease(token);
+    const latest = release.tag_name;
+    ui.info(`Latest:      ${latest}`);
+
+    console.log('');
+    if (local && local === latest) {
+      ui.success('Up to date.');
+    } else if (local) {
+      ui.warn(`Update available. Run: claudeflow update`);
+    }
+  } catch (err) {
+    ui.error(`Could not fetch latest release: ${err.message}`);
+  }
+  console.log('');
+}
+
+module.exports = run;
+module.exports.readLocalVersion = readLocalVersion;
+module.exports.writeLocalVersion = writeLocalVersion;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@axiomatic-labs/claudeflow",
+  "version": "2.0.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"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "ai-agents",
+    "ai-coding",
+    "developer-tools",
+    "cli",
+    "scaffolding",
+    "code-quality",
+    "automation",
+    "skills",
+    "agents",
+    "anthropic",
+    "llm",
+    "devtools"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/axiomatic-labs/axiomatic-cli.git"
+  },
+  "homepage": "https://claudeflow.dev",
+  "license": "UNLICENSED",
+  "private": false
+}