@girardmedia/bootspring 2.0.21 → 2.0.23

package/dist/cli/index.js

@@ -0,0 +1,3220 @@
+'use strict';
+const __create = Object.create;
+const __defProp = Object.defineProperty;
+const __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+const __getOwnPropNames = Object.getOwnPropertyNames;
+const __getProtoOf = Object.getPrototypeOf;
+const __hasOwnProp = Object.prototype.hasOwnProperty;
+const __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+const __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+const __export = (target, all) => {
+  for (const name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+const __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === 'object' || typeof from === 'function') {
+    for (const key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+const __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, 'default', { value: mod, enumerable: true }) : target,
+  mod
+));
+const __toCommonJS = (mod) => __copyProps(__defProp({}, '__esModule', { value: true }), mod);
+
+// node_modules/tsup/assets/cjs_shims.js
+const init_cjs_shims = __esm({
+  'node_modules/tsup/assets/cjs_shims.js'() {
+    'use strict';
+  }
+});
+
+// package.json
+const require_package = __commonJS({
+  'package.json'(exports2, module2) {
+    module2.exports = {
+      name: '@girardmedia/bootspring',
+      version: '2.0.21',
+      description: 'Development scaffolding with intelligence - AI-powered context, agents, and workflows for any MCP-compatible assistant',
+      keywords: [
+        'ai',
+        'development',
+        'scaffolding',
+        'mcp',
+        'claude',
+        'agents',
+        'context',
+        'workflow',
+        'devtools'
+      ],
+      author: 'Bootspring',
+      license: 'MIT',
+      repository: {
+        type: 'git',
+        url: 'https://github.com/bootspring/bootspring.git'
+      },
+      homepage: 'https://bootspring.com',
+      bugs: {
+        url: 'https://github.com/bootspring/bootspring/issues'
+      },
+      bin: {
+        bootspring: './bin/bootspring.js'
+      },
+      main: './core/index.js',
+      types: './core/index.d.ts',
+      exports: {
+        '.': {
+          types: './core/index.d.ts',
+          default: './core/index.js'
+        },
+        './mcp': {
+          types: './mcp/server.d.ts',
+          default: './mcp/server.js'
+        },
+        './auth': {
+          types: './core/auth.d.ts',
+          default: './core/auth.js'
+        },
+        './api': {
+          types: './core/api-client.d.ts',
+          default: './core/api-client.js'
+        },
+        './marketplace': {
+          types: './marketplace/index.d.ts',
+          default: './marketplace/index.js'
+        }
+      },
+      files: [
+        'bin/',
+        'core/',
+        'cli/',
+        'mcp/',
+        'intelligence/',
+        'quality/',
+        'generators/',
+        'hooks/',
+        'plugins/',
+        'marketplace/',
+        'src/',
+        'dist/'
+      ],
+      scripts: {
+        start: 'node bin/bootspring.js',
+        dashboard: 'node bin/bootspring.js dashboard',
+        mcp: 'node mcp/server.js',
+        test: 'jest',
+        'test:watch': 'jest --watch',
+        'test:coverage': 'jest --coverage',
+        lint: 'eslint .',
+        'lint:fix': 'eslint . --fix',
+        typecheck: 'tsc --noEmit',
+        build: 'tsup',
+        'build:watch': 'tsup --watch',
+        dev: 'tsx watch src/index.ts',
+        'verify:lint-budget': 'node scripts/check-lint-budgets.js',
+        'build:mcp-contract': 'node scripts/export-mcp-contract.js',
+        'verify:mcp-contract': 'node scripts/export-mcp-contract.js --check',
+        'verify:package': 'node scripts/check-package-boundaries.js',
+        'db:sync': 'node shared/db/sync.js',
+        'db:sync:check': 'node shared/db/sync.js --check',
+        prepublishOnly: 'npm test && npm run lint --if-present && npm run verify:package && npm run verify:mcp-contract'
+      },
+      devDependencies: {
+        '@eslint/js': '^9.39.2',
+        '@types/node': '^25.3.0',
+        eslint: '^9.39.2',
+        globals: '^17.3.0',
+        jest: '^29.7.0',
+        tsup: '^8.5.1',
+        tsx: '^4.21.0',
+        typescript: '^5.9.3'
+      },
+      dependencies: {
+        '@modelcontextprotocol/sdk': '^1.0.0',
+        ws: '^8.18.0',
+        yaml: '^2.8.0',
+        zod: '^3.25.0'
+      },
+      engines: {
+        node: '>=18.0.0'
+      },
+      overrides: {
+        table: {
+          ajv: '^8.12.0'
+        },
+        minimatch: '^10.2.1'
+      }
+    };
+  }
+});
+
+// src/core/auth.ts
+const auth_exports = {};
+__export(auth_exports, {
+  BOOTSPRING_DIR: () => BOOTSPRING_DIR,
+  CONFIG_FILE: () => CONFIG_FILE,
+  CREDENTIALS_FILE: () => CREDENTIALS_FILE,
+  DEVICE_FILE: () => DEVICE_FILE,
+  clearCredentials: () => clearCredentials,
+  clearDeviceInfo: () => clearDeviceInfo,
+  ensureDir: () => ensureDir2,
+  generateDeviceFingerprint: () => generateDeviceFingerprint,
+  getApiKey: () => getApiKey,
+  getConfig: () => getConfig,
+  getCredentials: () => getCredentials,
+  getCredentialsPath: () => getCredentialsPath,
+  getDeviceContext: () => getDeviceContext,
+  getDeviceId: () => getDeviceId,
+  getDeviceInfo: () => getDeviceInfo,
+  getRefreshToken: () => getRefreshToken,
+  getTier: () => getTier,
+  getToken: () => getToken,
+  getUser: () => getUser,
+  isApiKeyAuth: () => isApiKeyAuth,
+  isAuthenticated: () => isAuthenticated,
+  login: () => login,
+  loginWithApiKey: () => loginWithApiKey,
+  logout: () => logout,
+  saveConfig: () => saveConfig,
+  saveCredentials: () => saveCredentials,
+  updateTokens: () => updateTokens
+});
+function getEncryptionKey() {
+  const machineId = os.hostname() + os.userInfo().username;
+  return crypto.createHash('sha256').update(machineId).digest();
+}
+function ensureDir2() {
+  if (!fs2.existsSync(BOOTSPRING_DIR)) {
+    fs2.mkdirSync(BOOTSPRING_DIR, { recursive: true, mode: 448 });
+  }
+}
+function encrypt(data) {
+  try {
+    const key = getEncryptionKey();
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+    let encrypted = cipher.update(JSON.stringify(data), 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    return { iv: iv.toString('hex'), data: encrypted };
+  } catch {
+    return data;
+  }
+}
+function decrypt(encrypted) {
+  try {
+    if ('iv' in encrypted && 'data' in encrypted && typeof encrypted.iv === 'string') {
+      const key = getEncryptionKey();
+      const iv = Buffer.from(encrypted.iv, 'hex');
+      const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+      let decrypted = decipher.update(encrypted.data, 'hex', 'utf8');
+      decrypted += decipher.final('utf8');
+      return JSON.parse(decrypted);
+    }
+    return encrypted;
+  } catch {
+    return encrypted;
+  }
+}
+function getCredentials() {
+  try {
+    if (fs2.existsSync(CREDENTIALS_FILE)) {
+      const raw = JSON.parse(fs2.readFileSync(CREDENTIALS_FILE, 'utf-8'));
+      return decrypt(raw);
+    }
+  } catch {
+  }
+  return null;
+}
+function saveCredentials(credentials) {
+  ensureDir2();
+  const encrypted = encrypt(credentials);
+  fs2.writeFileSync(
+    CREDENTIALS_FILE,
+    JSON.stringify(encrypted, null, 2),
+    { mode: 384 }
+  );
+}
+function clearCredentials() {
+  try {
+    if (fs2.existsSync(CREDENTIALS_FILE)) {
+      fs2.unlinkSync(CREDENTIALS_FILE);
+    }
+  } catch {
+  }
+}
+function getToken() {
+  const creds = getCredentials();
+  if (!creds) return null;
+  if (creds.apiKey) return null;
+  if (creds.expiresAt && new Date(creds.expiresAt) < /* @__PURE__ */ new Date()) {
+    return null;
+  }
+  return creds.token || null;
+}
+function getApiKey() {
+  const creds = getCredentials();
+  return creds?.apiKey || null;
+}
+function isApiKeyAuth() {
+  const creds = getCredentials();
+  return !!creds?.apiKey;
+}
+function getRefreshToken() {
+  const creds = getCredentials();
+  return creds?.refreshToken || null;
+}
+function isAuthenticated() {
+  return !!getToken() || !!getApiKey();
+}
+function getUser() {
+  const creds = getCredentials();
+  return creds?.user || null;
+}
+function getTier() {
+  const user = getUser();
+  return user?.tier || 'free';
+}
+function parseExpiry(expiry) {
+  const match = expiry.match(/^(\d+)([mhd])$/);
+  if (!match || !match[1] || !match[2]) return 15 * 60 * 1e3;
+  const value = parseInt(match[1]);
+  const unit = match[2];
+  switch (unit) {
+    case 'm':
+      return value * 60 * 1e3;
+    case 'h':
+      return value * 60 * 60 * 1e3;
+    case 'd':
+      return value * 24 * 60 * 60 * 1e3;
+    default:
+      return 15 * 60 * 1e3;
+  }
+}
+function login(response) {
+  const expiresIn = response.expiresIn ?? '15m';
+  const expiresMs = parseExpiry(expiresIn);
+  const expiresAt = new Date(Date.now() + expiresMs).toISOString();
+  const credentials = {
+    token: response.token,
+    expiresAt
+  };
+  if (response.refreshToken !== void 0) {
+    credentials.refreshToken = response.refreshToken;
+  }
+  if (response.user !== void 0) {
+    credentials.user = response.user;
+  }
+  saveCredentials(credentials);
+}
+function loginWithApiKey(apiKey, user) {
+  const credentials = { apiKey };
+  if (user !== void 0) {
+    credentials.user = user;
+  }
+  saveCredentials(credentials);
+}
+function updateTokens(response) {
+  const creds = getCredentials() || {};
+  const expiresIn = response.expiresIn ?? '15m';
+  const expiresMs = parseExpiry(expiresIn);
+  const expiresAt = new Date(Date.now() + expiresMs).toISOString();
+  const credentials = {
+    ...creds,
+    token: response.token,
+    expiresAt
+  };
+  if (response.refreshToken !== void 0) {
+    credentials.refreshToken = response.refreshToken;
+  }
+  saveCredentials(credentials);
+}
+function logout() {
+  clearCredentials();
+}
+function getConfig() {
+  try {
+    if (fs2.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs2.readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+  } catch {
+  }
+  return {};
+}
+function saveConfig(config) {
+  ensureDir2();
+  fs2.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getCredentialsPath() {
+  return CREDENTIALS_FILE;
+}
+function generateDeviceFingerprint() {
+  const networkInterfaces2 = os.networkInterfaces();
+  const macAddresses = Object.values(networkInterfaces2).flat().filter(
+    (iface) => iface !== void 0 && !iface.internal && iface.mac !== '00:00:00:00:00:00'
+  ).map((iface) => iface.mac).sort().join(',');
+  const components = [
+    os.hostname(),
+    os.userInfo().username,
+    os.platform(),
+    os.arch(),
+    os.cpus()[0]?.model || 'unknown-cpu',
+    os.homedir(),
+    macAddresses
+  ];
+  return crypto.createHash('sha256').update(components.join('|')).digest('hex');
+}
+function getDeviceInfo() {
+  ensureDir2();
+  try {
+    if (fs2.existsSync(DEVICE_FILE)) {
+      const stored = JSON.parse(fs2.readFileSync(DEVICE_FILE, 'utf-8'));
+      const currentFingerprint = generateDeviceFingerprint();
+      if (stored.fingerprint === currentFingerprint) {
+        return stored;
+      }
+    }
+  } catch {
+  }
+  const deviceInfo = {
+    deviceId: crypto.randomUUID(),
+    fingerprint: generateDeviceFingerprint(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    platform: os.platform(),
+    arch: os.arch(),
+    hostname: os.hostname()
+  };
+  fs2.writeFileSync(DEVICE_FILE, JSON.stringify(deviceInfo, null, 2), { mode: 384 });
+  return deviceInfo;
+}
+function getDeviceId() {
+  return getDeviceInfo().deviceId;
+}
+function getDeviceContext() {
+  const info = getDeviceInfo();
+  let cliVersion = 'unknown';
+  try {
+    const pkg = require_package();
+    cliVersion = pkg.version;
+  } catch {
+  }
+  return {
+    deviceId: info.deviceId,
+    platform: info.platform,
+    arch: info.arch,
+    hostname: info.hostname,
+    cliVersion,
+    nodeVersion: process.version,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+  };
+}
+function clearDeviceInfo() {
+  try {
+    if (fs2.existsSync(DEVICE_FILE)) {
+      fs2.unlinkSync(DEVICE_FILE);
+    }
+  } catch {
+  }
+}
+let fs2, path2, os, crypto, BOOTSPRING_DIR, CREDENTIALS_FILE, CONFIG_FILE, DEVICE_FILE;
+const init_auth = __esm({
+  'src/core/auth.ts'() {
+    'use strict';
+    init_cjs_shims();
+    fs2 = __toESM(require('fs'));
+    path2 = __toESM(require('path'));
+    os = __toESM(require('os'));
+    crypto = __toESM(require('crypto'));
+    BOOTSPRING_DIR = path2.join(os.homedir(), '.bootspring');
+    CREDENTIALS_FILE = path2.join(BOOTSPRING_DIR, 'credentials.json');
+    CONFIG_FILE = path2.join(BOOTSPRING_DIR, 'config.json');
+    DEVICE_FILE = path2.join(BOOTSPRING_DIR, 'device.json');
+  }
+});
+
+// src/core/session.ts
+const session_exports = {};
+__export(session_exports, {
+  BOOTSPRING_DIR: () => BOOTSPRING_DIR2,
+  LOCAL_CONFIG_NAME: () => LOCAL_CONFIG_NAME,
+  SESSION_FILE: () => SESSION_FILE,
+  addRecentProject: () => addRecentProject,
+  clearSession: () => clearSession,
+  createLocalConfig: () => createLocalConfig,
+  ensureDir: () => ensureDir3,
+  findLocalConfig: () => findLocalConfig,
+  getCurrentProject: () => getCurrentProject,
+  getEffectiveProject: () => getEffectiveProject,
+  getRecentProjects: () => getRecentProjects,
+  getSession: () => getSession,
+  getSessionState: () => getSessionState,
+  saveSession: () => saveSession,
+  setCurrentProject: () => setCurrentProject
+});
+function ensureDir3() {
+  if (!fs3.existsSync(BOOTSPRING_DIR2)) {
+    fs3.mkdirSync(BOOTSPRING_DIR2, { recursive: true, mode: 448 });
+  }
+}
+function getSession() {
+  try {
+    if (fs3.existsSync(SESSION_FILE)) {
+      return JSON.parse(fs3.readFileSync(SESSION_FILE, 'utf-8'));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveSession(session) {
+  ensureDir3();
+  const data = {
+    ...session,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs3.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2));
+}
+function clearSession() {
+  try {
+    if (fs3.existsSync(SESSION_FILE)) {
+      fs3.unlinkSync(SESSION_FILE);
+    }
+  } catch {
+  }
+}
+function getCurrentProject() {
+  const session = getSession();
+  return session?.project || null;
+}
+function setCurrentProject(project) {
+  const session = getSession() || {};
+  session.project = project;
+  saveSession(session);
+}
+function getRecentProjects() {
+  const session = getSession();
+  return session?.recentProjects || [];
+}
+function addRecentProject(project) {
+  const session = getSession() || {};
+  const recent = session.recentProjects || [];
+  const filtered = recent.filter((p) => p.id !== project.id);
+  filtered.unshift({
+    id: project.id,
+    name: project.name,
+    slug: project.slug,
+    lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  session.recentProjects = filtered.slice(0, 10);
+  saveSession(session);
+}
+function findLocalConfig(startDir) {
+  let dir = startDir || process.cwd();
+  for (let i = 0; i < 10; i++) {
+    const jsonConfigPath = path3.join(dir, LOCAL_CONFIG_NAME);
+    if (fs3.existsSync(jsonConfigPath)) {
+      try {
+        const config = JSON.parse(fs3.readFileSync(jsonConfigPath, 'utf-8'));
+        return {
+          ...config,
+          _path: jsonConfigPath,
+          _dir: dir
+        };
+      } catch {
+      }
+    }
+    const jsConfigPath = path3.join(dir, 'bootspring.config.js');
+    if (fs3.existsSync(jsConfigPath)) {
+      try {
+        delete require.cache[require.resolve(jsConfigPath)];
+        const config = require(jsConfigPath);
+        if (config.projectId) {
+          const project = config.project;
+          return {
+            projectId: config.projectId,
+            projectName: project?.name || config.name || 'Unknown',
+            projectSlug: project?.slug,
+            _path: jsConfigPath,
+            _dir: dir,
+            _fromJsConfig: true
+          };
+        }
+      } catch {
+      }
+    }
+    const parent = path3.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function getEffectiveProject() {
+  const local = findLocalConfig();
+  if (local?.projectId) {
+    return {
+      id: local.projectId,
+      name: local.projectName || 'Unknown',
+      slug: local.projectSlug,
+      source: 'local',
+      _localConfig: local
+    };
+  }
+  const sessionProject = getCurrentProject();
+  if (sessionProject) {
+    return {
+      ...sessionProject,
+      source: 'session'
+    };
+  }
+  return null;
+}
+function createLocalConfig(dir, project) {
+  const configPath = path3.join(dir, LOCAL_CONFIG_NAME);
+  const config = {
+    projectId: project.id,
+    projectName: project.name,
+    projectSlug: project.slug,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs3.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  return configPath;
+}
+function getSessionState() {
+  const session = getSession();
+  const effective = getEffectiveProject();
+  const local = findLocalConfig();
+  return {
+    hasSession: !!session,
+    project: effective,
+    source: effective?.source || null,
+    hasLocalConfig: !!local,
+    localConfigPath: local?._path,
+    recentProjects: session?.recentProjects || [],
+    lastUpdated: session?.updatedAt || null
+  };
+}
+let fs3, path3, os2, BOOTSPRING_DIR2, SESSION_FILE, LOCAL_CONFIG_NAME;
+const init_session = __esm({
+  'src/core/session.ts'() {
+    'use strict';
+    init_cjs_shims();
+    fs3 = __toESM(require('fs'));
+    path3 = __toESM(require('path'));
+    os2 = __toESM(require('os'));
+    BOOTSPRING_DIR2 = path3.join(os2.homedir(), '.bootspring');
+    SESSION_FILE = path3.join(BOOTSPRING_DIR2, 'session.json');
+    LOCAL_CONFIG_NAME = '.bootspring.json';
+  }
+});
+
+// intelligence/git-memory.js
+const require_git_memory = __commonJS({
+  'intelligence/git-memory.js'(exports2, module2) {
+    'use strict';
+    init_cjs_shims();
+    const { execSync } = require('child_process');
+    const MEMORY_CATEGORIES = {
+      DECISION: {
+        patterns: [
+          /decided to/i,
+          /chose to/i,
+          /switched to/i,
+          /migrated to/i,
+          /now using/i,
+          /replaced .+ with/i,
+          /prefer/i
+        ],
+        icon: '\u{1F3AF}',
+        label: 'Decisions'
+      },
+      BUGFIX: {
+        patterns: [
+          /fix(ed|es)?:/i,
+          /bug(fix)?:/i,
+          /resolved/i,
+          /patched/i,
+          /was causing/i,
+          /issue with/i,
+          /broke/i,
+          /fixed by/i
+        ],
+        icon: '\u{1F41B}',
+        label: 'Bug Fixes & Gotchas'
+      },
+      PATTERN: {
+        patterns: [
+          /pattern/i,
+          /refactor/i,
+          /abstracted/i,
+          /extracted/i,
+          /standardized/i,
+          /convention/i,
+          /approach/i
+        ],
+        icon: '\u{1F527}',
+        label: 'Patterns & Conventions'
+      },
+      ARCHITECTURE: {
+        patterns: [
+          /architect/i,
+          /structure/i,
+          /reorganiz/i,
+          /module/i,
+          /split/i,
+          /merged/i,
+          /moved .+ to/i,
+          /renamed/i
+        ],
+        icon: '\u{1F3D7}\uFE0F',
+        label: 'Architecture'
+      },
+      DEPENDENCY: {
+        patterns: [
+          /added .+ dependency/i,
+          /upgraded/i,
+          /downgraded/i,
+          /pinned/i,
+          /removed .+ package/i,
+          /npm/i,
+          /yarn/i
+        ],
+        icon: '\u{1F4E6}',
+        label: 'Dependencies'
+      },
+      PERFORMANCE: {
+        patterns: [
+          /performance/i,
+          /optimiz/i,
+          /faster/i,
+          /slower/i,
+          /memory/i,
+          /cache/i,
+          /lazy/i,
+          /async/i
+        ],
+        icon: '\u26A1',
+        label: 'Performance'
+      },
+      SECURITY: {
+        patterns: [
+          /security/i,
+          /vulnerab/i,
+          /auth/i,
+          /permission/i,
+          /sanitiz/i,
+          /validat/i,
+          /escape/i,
+          /inject/i
+        ],
+        icon: '\u{1F512}',
+        label: 'Security'
+      },
+      CONFIG: {
+        patterns: [
+          /config/i,
+          /environment/i,
+          /\.env/i,
+          /settings/i,
+          /setup/i,
+          /initialize/i
+        ],
+        icon: '\u2699\uFE0F',
+        label: 'Configuration'
+      }
+    };
+    function git(command, options = {}) {
+      try {
+        const cwd = options.cwd || process.cwd();
+        return execSync(`git ${command}`, {
+          cwd,
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+      } catch (e) {
+        if (options.throwOnError) throw e;
+        return '';
+      }
+    }
+    function isGitRepo(cwd = process.cwd()) {
+      try {
+        git('rev-parse --git-dir', { cwd, throwOnError: true });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function getCommits(options = {}) {
+      const {
+        limit = 100,
+        since = null,
+        until = null,
+        author = null,
+        path: filePath = null,
+        cwd = process.cwd()
+      } = options;
+      let command = `log --pretty=format:"%H|||%ai|||%an|||%s%x00" -n ${limit}`;
+      if (since) command += ` --since="${since}"`;
+      if (until) command += ` --until="${until}"`;
+      if (author) command += ` --author="${author}"`;
+      if (filePath) command += ` -- "${filePath}"`;
+      const output = git(command, { cwd });
+      if (!output) return [];
+      return output.split('\0').filter((record) => record.trim()).map((record) => {
+        const [hash, date, author2, subject] = record.trim().split('|||');
+        return {
+          hash: hash?.slice(0, 8),
+          date,
+          author: author2,
+          subject,
+          body: '',
+          // Body extraction removed for simplicity - subject is enough for categorization
+          fullMessage: subject || ''
+        };
+      }).filter((c) => c.hash && c.hash.length === 8);
+    }
+    function categorizeCommit(commit) {
+      const categories = [];
+      for (const [category, config] of Object.entries(MEMORY_CATEGORIES)) {
+        for (const pattern of config.patterns) {
+          if (pattern.test(commit.fullMessage)) {
+            categories.push(category);
+            break;
+          }
+        }
+      }
+      if (categories.length === 0) {
+        categories.push('GENERAL');
+      }
+      return categories;
+    }
+    function getCommitFiles(hash, cwd = process.cwd()) {
+      const output = git(`show --name-only --pretty=format:"" ${hash}`, { cwd });
+      return output.split('\n').filter((f) => f.trim());
+    }
+    function extractLearnings(options = {}) {
+      const {
+        limit = 50,
+        since = '3 months ago',
+        cwd = process.cwd(),
+        includeFiles = false
+      } = options;
+      if (!isGitRepo(cwd)) {
+        return { error: 'Not a git repository', learnings: [] };
+      }
+      const commits = getCommits({ limit, since, cwd });
+      const learnings = [];
+      for (const commit of commits) {
+        const categories = categorizeCommit(commit);
+        if (isMundaneCommit(commit)) continue;
+        const learning = {
+          hash: commit.hash,
+          date: commit.date,
+          categories,
+          summary: commit.subject,
+          details: commit.body || null,
+          importance: calculateImportance(commit, categories)
+        };
+        if (includeFiles) {
+          learning.files = getCommitFiles(commit.hash, cwd);
+        }
+        learnings.push(learning);
+      }
+      learnings.sort((a, b) => b.importance - a.importance);
+      return { learnings, total: commits.length };
+    }
+    function isMundaneCommit(commit) {
+      const mundanePatterns = [
+        /^merge/i,
+        /^wip/i,
+        /^temp/i,
+        /^bump version/i,
+        /^update changelog/i,
+        /^lint/i,
+        /^format/i,
+        /^typo/i,
+        /^minor/i,
+        /^small/i
+      ];
+      return mundanePatterns.some((p) => p.test(commit.subject));
+    }
+    function calculateImportance(commit, categories) {
+      let score = 0;
+      const weights = {
+        DECISION: 10,
+        ARCHITECTURE: 9,
+        SECURITY: 8,
+        BUGFIX: 7,
+        PATTERN: 6,
+        PERFORMANCE: 5,
+        DEPENDENCY: 4,
+        CONFIG: 3,
+        GENERAL: 1
+      };
+      for (const cat of categories) {
+        score += weights[cat] || 1;
+      }
+      if (commit.body && commit.body.length > 50) {
+        score += 2;
+      }
+      if (/^(feat|fix|refactor|perf|security):/i.test(commit.subject)) {
+        score += 2;
+      }
+      return score;
+    }
+    function groupByCategory(learnings) {
+      const grouped = {};
+      for (const learning of learnings) {
+        for (const category of learning.categories) {
+          if (!grouped[category]) {
+            grouped[category] = [];
+          }
+          grouped[category].push(learning);
+        }
+      }
+      return grouped;
+    }
+    function toMarkdown(learnings, options = {}) {
+      const { title = 'Project Learnings', maxPerCategory = 5 } = options;
+      const grouped = groupByCategory(learnings);
+      let md = `## ${title}
+
+`;
+      md += `> Extracted from ${learnings.length} significant commits
+
+`;
+      for (const [category, items] of Object.entries(grouped)) {
+        const config = MEMORY_CATEGORIES[category] || { icon: '\u{1F4DD}', label: category };
+        const topItems = items.slice(0, maxPerCategory);
+        md += `### ${config.icon} ${config.label}
+
+`;
+        for (const item of topItems) {
+          md += `- **${item.summary}**`;
+          if (item.details) {
+            const firstLine = item.details.split('\n')[0].trim();
+            if (firstLine && firstLine.length < 100) {
+              md += ` - ${firstLine}`;
+            }
+          }
+          md += ` _(${item.hash})_
+`;
+        }
+        md += '\n';
+      }
+      return md;
+    }
+    function toCompactSummary(learnings, options = {}) {
+      const { maxItems = 15 } = options;
+      const topLearnings = learnings.slice(0, maxItems);
+      let summary = '## Recent Learnings\n\n';
+      summary += 'Key decisions and patterns from recent development:\n\n';
+      for (const learning of topLearnings) {
+        const categoryIcons = learning.categories.map((c) => MEMORY_CATEGORIES[c]?.icon || '\u{1F4DD}').join('');
+        summary += `- ${categoryIcons} ${learning.summary}
+`;
+      }
+      return summary;
+    }
+    function searchLearnings(learnings, query) {
+      const queryLower = query.toLowerCase();
+      return learnings.filter((l) => {
+        return l.summary.toLowerCase().includes(queryLower) || l.details && l.details.toLowerCase().includes(queryLower) || l.categories.some((c) => c.toLowerCase().includes(queryLower));
+      });
+    }
+    function getLearningsForFiles(files, options = {}) {
+      const { cwd = process.cwd(), limit = 20 } = options;
+      const learnings = [];
+      for (const file of files) {
+        const commits = getCommits({ limit: 10, path: file, cwd });
+        for (const commit of commits) {
+          if (!isMundaneCommit(commit)) {
+            const categories = categorizeCommit(commit);
+            learnings.push({
+              hash: commit.hash,
+              date: commit.date,
+              categories,
+              summary: commit.subject,
+              details: commit.body,
+              file,
+              importance: calculateImportance(commit, categories)
+            });
+          }
+        }
+      }
+      const seen = /* @__PURE__ */ new Set();
+      return learnings.filter((l) => {
+        if (seen.has(l.hash)) return false;
+        seen.add(l.hash);
+        return true;
+      }).sort((a, b) => b.importance - a.importance).slice(0, limit);
+    }
+    function getRepoStats(cwd = process.cwd()) {
+      if (!isGitRepo(cwd)) {
+        return null;
+      }
+      const totalCommits = parseInt(git('rev-list --count HEAD', { cwd }) || '0');
+      const firstCommit = git('log --reverse --pretty=format:"%ai" | head -1', { cwd });
+      const contributors = git('shortlog -sn --no-merges', { cwd }).split('\n').filter((l) => l.trim()).length;
+      const recentActivity = git('log --since="1 week ago" --oneline', { cwd }).split('\n').filter((l) => l.trim()).length;
+      return {
+        totalCommits,
+        firstCommit,
+        contributors,
+        recentActivity,
+        weeklyPace: recentActivity
+      };
+    }
+    if (require.main === module2) {
+      const args = process.argv.slice(2);
+      const command = args[0] || 'summary';
+      switch (command) {
+        case 'extract': {
+          const result = extractLearnings({
+            limit: parseInt(args[1]) || 50,
+            includeFiles: args.includes('--files')
+          });
+          if (result.error) {
+            console.error(result.error);
+            process.exit(1);
+          }
+          console.log(JSON.stringify(result.learnings, null, 2));
+          break;
+        }
+        case 'summary': {
+          const result = extractLearnings({ limit: 50 });
+          if (result.error) {
+            console.error(result.error);
+            process.exit(1);
+          }
+          console.log(toMarkdown(result.learnings));
+          break;
+        }
+        case 'compact': {
+          const result = extractLearnings({ limit: 30 });
+          if (result.error) {
+            console.error(result.error);
+            process.exit(1);
+          }
+          console.log(toCompactSummary(result.learnings));
+          break;
+        }
+        case 'search': {
+          const query = args.slice(1).join(' ');
+          if (!query) {
+            console.error('Usage: git-memory.js search <query>');
+            process.exit(1);
+          }
+          const result = extractLearnings({ limit: 100 });
+          const matches = searchLearnings(result.learnings, query);
+          console.log(`Found ${matches.length} matches for "${query}":
+`);
+          for (const match of matches.slice(0, 10)) {
+            console.log(`  [${match.hash}] ${match.summary}`);
+          }
+          break;
+        }
+        case 'stats': {
+          const stats = getRepoStats();
+          if (!stats) {
+            console.error('Not a git repository');
+            process.exit(1);
+          }
+          console.log(JSON.stringify(stats, null, 2));
+          break;
+        }
+        case 'categories': {
+          console.log('\nAvailable categories:\n');
+          for (const [key, config] of Object.entries(MEMORY_CATEGORIES)) {
+            console.log(`  ${config.icon} ${key.padEnd(15)} ${config.label}`);
+          }
+          console.log();
+          break;
+        }
+        default:
+          console.log(`
+Bootspring Git Memory
+
+Usage:
+  git-memory.js extract [limit] [--files]   Extract learnings as JSON
+  git-memory.js summary                     Generate markdown summary
+  git-memory.js compact                     Compact summary for CLAUDE.md
+  git-memory.js search <query>              Search learnings
+  git-memory.js stats                       Repository statistics
+  git-memory.js categories                  List memory categories
+`);
+      }
+    }
+    module2.exports = {
+      isGitRepo,
+      getCommits,
+      extractLearnings,
+      groupByCategory,
+      toMarkdown,
+      toCompactSummary,
+      searchLearnings,
+      getLearningsForFiles,
+      getRepoStats,
+      MEMORY_CATEGORIES
+    };
+  }
+});
+
+// generators/templates/agents.template.js
+const require_agents_template = __commonJS({
+  'generators/templates/agents.template.js'(exports2, module2) {
+    'use strict';
+    init_cjs_shims();
+    function generate(config) {
+      const sections = [];
+      sections.push(`# ${config.project.name}`);
+      sections.push('');
+      sections.push(`You are a senior full-stack developer working on ${config.project.name}, a ${formatFramework(config.stack.framework)} application with ${config.stack.language}.`);
+      sections.push('');
+      sections.push('## Commands');
+      sections.push('');
+      sections.push('```bash');
+      sections.push('# Development');
+      sections.push('npm run dev');
+      sections.push('');
+      sections.push('# Quality checks (run before committing)');
+      sections.push('npm run lint');
+      sections.push('npm run test');
+      sections.push('npm run typecheck');
+      sections.push('');
+      sections.push('# Build tasks');
+      sections.push('bootspring build next    # Get next task');
+      sections.push('bootspring build done    # Mark task complete');
+      sections.push('bootspring build status  # Check progress');
+      sections.push('```');
+      sections.push('');
+      sections.push('## Build Loop');
+      sections.push('');
+      sections.push('**Start building:**');
+      sections.push('```');
+      sections.push('bootspring build next');
+      sections.push('```');
+      sections.push('');
+      sections.push('This loops through all tasks:');
+      sections.push('1. Find in_progress task in `planning/TASK_QUEUE.md`');
+      sections.push('2. Implement following acceptance criteria');
+      sections.push('3. Run `bootspring build done`');
+      sections.push('4. Continue to next task (auto-queued)');
+      sections.push('');
+      sections.push('**Keep looping until MVP complete.**');
+      sections.push('');
+      sections.push('## Stack');
+      sections.push('');
+      sections.push(`- **Framework**: ${formatFramework(config.stack.framework)}`);
+      sections.push(`- **Language**: ${config.stack.language}`);
+      if (config.stack.database !== 'none') {
+        sections.push(`- **Database**: ${config.stack.database}`);
+        if (config.stack.orm) {
+          sections.push(`- **ORM**: ${config.stack.orm}`);
+        }
+      }
+      sections.push('');
+      sections.push('## Code Style');
+      sections.push('');
+      if (config.stack.framework === 'nextjs') {
+        sections.push('- Use Server Components by default');
+        sections.push('- Use Server Actions for mutations (not API routes)');
+      }
+      sections.push('- Use Zod for input validation');
+      sections.push('- Keep files under 300 lines');
+      sections.push('- Use meaningful variable and function names');
+      sections.push('- Follow existing patterns in the codebase');
+      sections.push('');
+      sections.push('## Git Workflow');
+      sections.push('');
+      sections.push('- Conventional commits: `feat:`, `fix:`, `docs:`, `refactor:`');
+      sections.push('- Atomic commits - one logical change per commit');
+      sections.push('- Run quality checks before committing');
+      sections.push('- Never force push to main');
+      sections.push('- **Never add Co-Authored-By or AI attribution to commits**');
+      sections.push('');
+      sections.push('## Boundaries');
+      sections.push('');
+      sections.push('**Never:**');
+      sections.push('- Commit secrets, API keys, or credentials');
+      sections.push('- Modify `.env` files with real values');
+      sections.push('- Delete or overwrite migration files');
+      sections.push('- Skip tests to make code compile');
+      sections.push('- Introduce breaking changes without discussion');
+      sections.push('');
+      sections.push('**Always:**');
+      sections.push('- Read existing code before modifying');
+      sections.push('- Run tests after changes');
+      sections.push('- Check for TypeScript errors');
+      sections.push('- Follow the acceptance criteria exactly');
+      sections.push('');
+      sections.push('## Testing');
+      sections.push('');
+      sections.push('- Write tests for new features');
+      sections.push('- Ensure existing tests still pass');
+      sections.push('- Test edge cases and error conditions');
+      sections.push('');
+      return sections.join('\n');
+    }
+    function generatePlanningAgents(_config) {
+      const sections = [];
+      sections.push('# Planning Directory');
+      sections.push('');
+      sections.push('You are working on build tasks for the MVP. This directory contains build planning files.');
+      sections.push('');
+      sections.push('## Current Task');
+      sections.push('');
+      sections.push('Find the task with `status: in_progress` in `TASK_QUEUE.md`.');
+      sections.push('');
+      sections.push('## Commands');
+      sections.push('');
+      sections.push('```bash');
+      sections.push('bootspring build done    # Mark task complete, get next');
+      sections.push('bootspring build skip    # Skip task, get next');
+      sections.push('bootspring build status  # View progress');
+      sections.push('```');
+      sections.push('');
+      sections.push('## Files');
+      sections.push('');
+      sections.push('| File | Purpose |');
+      sections.push('|------|---------|');
+      sections.push('| `TASK_QUEUE.md` | All tasks - find in_progress task |');
+      sections.push('| `TODO.md` | Full task checklist |');
+      sections.push('| `BUILD_STATE.json` | Build state (do not edit) |');
+      sections.push('| `TASK_QUEUE.md` | Ordered task queue |');
+      sections.push('| `CONTEXT.md` | Build context summary |');
+      sections.push('');
+      sections.push('## Workflow');
+      sections.push('');
+      sections.push('1. Find in_progress task in `TASK_QUEUE.md`');
+      sections.push('2. Implement in the main codebase (not here)');
+      sections.push('3. Ensure acceptance criteria met');
+      sections.push('4. Run `npm run lint && npm run test`');
+      sections.push('5. Commit changes');
+      sections.push('6. Run `bootspring build done`');
+      sections.push('');
+      sections.push('## Boundaries');
+      sections.push('');
+      sections.push('- Do NOT edit `BUILD_STATE.json` directly');
+      sections.push('- Do NOT skip quality checks');
+      sections.push('- Do NOT work on multiple tasks at once');
+      sections.push('');
+      return sections.join('\n');
+    }
+    function formatFramework(framework) {
+      const names = {
+        'nextjs': 'Next.js 14+ (App Router)',
+        'remix': 'Remix',
+        'nuxt': 'Nuxt 3',
+        'sveltekit': 'SvelteKit',
+        'express': 'Express.js',
+        'fastify': 'Fastify',
+        'hono': 'Hono'
+      };
+      return names[framework] || framework;
+    }
+    module2.exports = {
+      generate,
+      generatePlanningAgents
+    };
+  }
+});
+
+// src/cli/index.ts
+const cli_exports = {};
+__export(cli_exports, {
+  dashboard: () => dashboard_exports,
+  generate: () => generate_exports,
+  generateClaudeMd: () => generateClaudeMd,
+  runDashboard: () => run2,
+  runGenerate: () => run3,
+  runTelemetry: () => run,
+  runTodo: () => run4,
+  telemetry: () => telemetry_exports,
+  todo: () => todo_exports
+});
+module.exports = __toCommonJS(cli_exports);
+init_cjs_shims();
+
+// src/cli/telemetry.ts
+var telemetry_exports = {};
+__export(telemetry_exports, {
+  run: () => run
+});
+init_cjs_shims();
+
+// src/core/utils.ts
+init_cjs_shims();
+const fs = __toESM(require('fs'));
+const path = __toESM(require('path'));
+const COLORS = {
+  reset: '\x1B[0m',
+  bold: '\x1B[1m',
+  dim: '\x1B[2m',
+  italic: '\x1B[3m',
+  underline: '\x1B[4m',
+  // Foreground
+  black: '\x1B[30m',
+  red: '\x1B[31m',
+  green: '\x1B[32m',
+  yellow: '\x1B[33m',
+  blue: '\x1B[34m',
+  magenta: '\x1B[35m',
+  cyan: '\x1B[36m',
+  white: '\x1B[37m',
+  // Background
+  bgBlack: '\x1B[40m',
+  bgRed: '\x1B[41m',
+  bgGreen: '\x1B[42m',
+  bgYellow: '\x1B[43m',
+  bgBlue: '\x1B[44m',
+  bgMagenta: '\x1B[45m',
+  bgCyan: '\x1B[46m',
+  bgWhite: '\x1B[47m'
+};
+const print = {
+  info: (msg) => console.log(`${COLORS.cyan}\u2139${COLORS.reset} ${msg}`),
+  success: (msg) => console.log(`${COLORS.green}\u2713${COLORS.reset} ${msg}`),
+  warning: (msg) => console.log(`${COLORS.yellow}\u26A0${COLORS.reset} ${msg}`),
+  error: (msg) => console.log(`${COLORS.red}\u2717${COLORS.reset} ${msg}`),
+  debug: (msg) => {
+    if (process.env.DEBUG) {
+      console.log(`${COLORS.dim}\u22EF ${msg}${COLORS.reset}`);
+    }
+  },
+  header: (msg) => console.log(`
+${COLORS.bold}${COLORS.cyan}${msg}${COLORS.reset}
+`),
+  dim: (msg) => console.log(`${COLORS.dim}${msg}${COLORS.reset}`),
+  brand: (msg) => console.log(`${COLORS.cyan}\u26A1${COLORS.reset} ${msg}`)
+};
+function createSpinner(message) {
+  const frames = ['\u280B', '\u2819', '\u2839', '\u2838', '\u283C', '\u2834', '\u2826', '\u2827', '\u2807', '\u280F'];
+  let frameIndex = 0;
+  let interval = null;
+  const isTTY = process.stdout.isTTY;
+  const clearLine = () => {
+    if (isTTY && process.stdout.clearLine) {
+      process.stdout.clearLine(0);
+      process.stdout.cursorTo(0);
+    }
+  };
+  return {
+    start() {
+      if (isTTY) {
+        process.stdout.write(`${COLORS.cyan}${frames[0]}${COLORS.reset} ${message}`);
+        interval = setInterval(() => {
+          frameIndex = (frameIndex + 1) % frames.length;
+          clearLine();
+          process.stdout.write(`${COLORS.cyan}${frames[frameIndex]}${COLORS.reset} ${message}`);
+        }, 80);
+      }
+      return this;
+    },
+    succeed(text = message) {
+      if (interval) clearInterval(interval);
+      clearLine();
+      console.log(`${COLORS.green}\u2713${COLORS.reset} ${text}`);
+      return this;
+    },
+    fail(text = message) {
+      if (interval) clearInterval(interval);
+      clearLine();
+      console.log(`${COLORS.red}\u2717${COLORS.reset} ${text}`);
+      return this;
+    },
+    warn(text = message) {
+      if (interval) clearInterval(interval);
+      clearLine();
+      console.log(`${COLORS.yellow}\u26A0${COLORS.reset} ${text}`);
+      return this;
+    },
+    info(text = message) {
+      if (interval) clearInterval(interval);
+      clearLine();
+      console.log(`${COLORS.cyan}\u2139${COLORS.reset} ${text}`);
+      return this;
+    },
+    stop() {
+      if (interval) clearInterval(interval);
+      clearLine();
+      return this;
+    }
+  };
+}
+function ensureDir(dirPath) {
+  try {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readFile(filepath, defaultValue = null) {
+  try {
+    return fs.readFileSync(filepath, 'utf-8');
+  } catch {
+    return defaultValue;
+  }
+}
+function writeFile(filepath, content) {
+  try {
+    const dir = path.dirname(filepath);
+    ensureDir(dir);
+    fs.writeFileSync(filepath, content, 'utf-8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+function fileExists(filepath) {
+  try {
+    return fs.existsSync(filepath);
+  } catch {
+    return false;
+  }
+}
+function getFileTime(filepath) {
+  try {
+    const stats = fs.statSync(filepath);
+    return stats.mtime;
+  } catch {
+    return null;
+  }
+}
+function formatDate(date = /* @__PURE__ */ new Date()) {
+  const parts = date.toISOString().split('T');
+  return parts[0] ?? date.toISOString().substring(0, 10);
+}
+function parseArgs(args) {
+  const result = { _: [] };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const nextArg = args[i + 1];
+      if (key.includes('=')) {
+        const parts = key.split('=');
+        const k = parts[0];
+        const v = parts.slice(1).join('=');
+        if (k) result[k] = v;
+      } else if (nextArg && !nextArg.startsWith('-')) {
+        result[key] = nextArg;
+        i++;
+      } else {
+        result[key] = true;
+      }
+    } else if (arg.startsWith('-') && arg.length === 2) {
+      const key = arg.slice(1);
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith('-')) {
+        result[key] = nextArg;
+        i++;
+      } else {
+        result[key] = true;
+      }
+    } else if (arg.startsWith('-')) {
+      const keys = arg.slice(1).split('');
+      for (const key of keys) {
+        if (key) result[key] = true;
+      }
+    } else {
+      result._.push(arg);
+    }
+  }
+  return result;
+}
+
+// src/core/telemetry.ts
+init_cjs_shims();
+const fs4 = __toESM(require('fs'));
+const path4 = __toESM(require('path'));
+const crypto2 = __toESM(require('crypto'));
+const MAX_EVENTS_LIMIT = 1e4;
+function getTelemetryDir(projectRoot = process.cwd()) {
+  return path4.join(projectRoot, '.bootspring', 'telemetry');
+}
+function getTelemetryFile(projectRoot = process.cwd()) {
+  return path4.join(getTelemetryDir(projectRoot), 'events.jsonl');
+}
+function parseEventLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function listEvents(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const file = getTelemetryFile(projectRoot);
+  if (!fs4.existsSync(file)) return [];
+  const eventFilter = String(options.event || '').trim();
+  const from = options.from ? new Date(options.from).getTime() : null;
+  const to = options.to ? new Date(options.to).getTime() : null;
+  const limit = Number(options.limit);
+  const lines = fs4.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+  let records = lines.map(parseEventLine).filter((record) => record !== null).filter((record) => {
+    if (eventFilter && record.event !== eventFilter) return false;
+    const ts = new Date(record.timestamp).getTime();
+    if (Number.isFinite(from) && from !== null && ts < from) return false;
+    if (Number.isFinite(to) && to !== null && ts > to) return false;
+    return true;
+  });
+  const effectiveLimit = Number.isFinite(limit) && limit > 0 ? Math.min(limit, MAX_EVENTS_LIMIT) : MAX_EVENTS_LIMIT;
+  records = records.slice(-effectiveLimit);
+  return records;
+}
+function clearEvents(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const file = getTelemetryFile(projectRoot);
+  const records = listEvents({ projectRoot });
+  if (fs4.existsSync(file)) {
+    fs4.writeFileSync(file, '', 'utf-8');
+  }
+  return {
+    cleared: records.length,
+    file
+  };
+}
+function getStatus(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const file = getTelemetryFile(projectRoot);
+  const records = listEvents({ projectRoot });
+  const lastRecord = records.length > 0 ? records[records.length - 1] : null;
+  return {
+    file,
+    exists: fs4.existsSync(file),
+    count: records.length,
+    lastEventAt: lastRecord?.timestamp ?? null
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function chunkArray(items, size) {
+  const chunks = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+}
+async function postBatchWithRetry(endpoint, body, headers, options = {}) {
+  const maxRetries = Number(options.maxRetries);
+  const retryDelayMs = Number(options.retryDelayMs);
+  const retries = Number.isFinite(maxRetries) && maxRetries >= 0 ? maxRetries : 2;
+  const delayBase = Number.isFinite(retryDelayMs) && retryDelayMs > 0 ? retryDelayMs : 300;
+  let attempt = 0;
+  while (true) {
+    try {
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return { success: true, attempts: attempt + 1 };
+    } catch (error) {
+      if (attempt >= retries) {
+        return {
+          success: false,
+          attempts: attempt + 1,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+      attempt += 1;
+      const delay = delayBase * 2 ** (attempt - 1);
+      await sleep(delay);
+    }
+  }
+}
+async function uploadEvents(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const API_BASE = process.env.BOOTSPRING_API_URL || 'https://www.bootspring.com';
+  const defaultEndpoint = `${API_BASE}/api/v1/events/batch`;
+  const endpoint = options.endpoint || process.env.BOOTSPRING_TELEMETRY_ENDPOINT || defaultEndpoint;
+  const token = options.token || process.env.BOOTSPRING_TELEMETRY_TOKEN;
+  const event = options.event;
+  const limit = Number(options.limit) || void 0;
+  const batchSizeOption = Number(options.batchSize || process.env.BOOTSPRING_TELEMETRY_BATCH_SIZE);
+  const batchSize = Number.isFinite(batchSizeOption) && batchSizeOption > 0 ? batchSizeOption : 100;
+  const clearOnSuccess = options.clearOnSuccess === true;
+  const records = listEvents({ projectRoot, event, limit });
+  if (records.length === 0) {
+    return {
+      uploaded: 0,
+      remaining: 0,
+      endpoint
+    };
+  }
+  let apiKey = null;
+  let projectId = null;
+  try {
+    const auth = await Promise.resolve().then(() => (init_auth(), auth_exports));
+    const session = await Promise.resolve().then(() => (init_session(), session_exports));
+    apiKey = auth.getApiKey();
+    const project = session.getEffectiveProject();
+    projectId = project?.id ?? null;
+  } catch {
+  }
+  let version = 'unknown';
+  try {
+    const pkg = require_package();
+    version = pkg.version;
+  } catch {
+  }
+  const headers = {
+    'content-type': 'application/json',
+    accept: 'application/json',
+    'user-agent': `bootspring-cli/${version}`
+  };
+  if (apiKey) {
+    headers['x-api-key'] = apiKey;
+  } else if (token) {
+    headers.authorization = `Bearer ${token}`;
+  }
+  if (projectId) {
+    headers['x-project-id'] = projectId;
+  }
+  const batches = chunkArray(records, batchSize);
+  let uploaded = 0;
+  let totalAttempts = 0;
+  const failedBatches = [];
+  for (let i = 0; i < batches.length; i++) {
+    const events = batches[i];
+    if (!events) continue;
+    const batchId = crypto2.createHash('sha1').update(JSON.stringify(events)).digest('hex');
+    const result = await postBatchWithRetry(
+      endpoint,
+      {
+        source: 'bootspring',
+        batch: {
+          index: i,
+          total: batches.length,
+          id: batchId
+        },
+        events
+      },
+      {
+        ...headers,
+        'x-bootspring-batch-id': batchId
+      },
+      options
+    );
+    totalAttempts += result.attempts ?? 1;
+    if (!result.success) {
+      failedBatches.push({
+        index: i,
+        count: events.length,
+        error: result.error ?? 'upload_failed'
+      });
+      continue;
+    }
+    uploaded += events.length;
+  }
+  if (failedBatches.length > 0) {
+    throw new Error(`Telemetry upload failed for ${failedBatches.length}/${batches.length} batches`);
+  }
+  if (clearOnSuccess) {
+    clearEvents({ projectRoot });
+  }
+  const remaining = clearOnSuccess ? 0 : listEvents({ projectRoot }).length;
+  return {
+    uploaded,
+    attempted: records.length,
+    batches: batches.length,
+    attempts: totalAttempts,
+    remaining,
+    endpoint,
+    failedBatches
+  };
+}
+
+// src/cli/telemetry.ts
+function showStatus() {
+  const status = getStatus();
+  console.log(`
+${COLORS.cyan}${COLORS.bold}Telemetry Status${COLORS.reset}
+${COLORS.dim}File: ${status.file}${COLORS.reset}
+${COLORS.dim}Events: ${status.count}${COLORS.reset}
+${COLORS.dim}Last event: ${status.lastEventAt ?? 'none'}${COLORS.reset}
+`);
+}
+function listEvents2(options = {}) {
+  const listOptions = {
+    event: options.event,
+    limit: options.limit
+  };
+  const records = listEvents(listOptions);
+  if (records.length === 0) {
+    print.warning('No telemetry events found');
+    return;
+  }
+  records.forEach((record) => {
+    console.log(`${COLORS.cyan}${record.timestamp}${COLORS.reset} ${record.event}`);
+  });
+  console.log(`
+${COLORS.dim}${records.length} event(s)${COLORS.reset}`);
+}
+async function upload(options = {}) {
+  const spinner = createSpinner('Uploading telemetry events').start();
+  try {
+    const uploadOptions = {
+      endpoint: options.endpoint,
+      token: options.token,
+      event: options.event,
+      limit: options.limit,
+      clearOnSuccess: options.clear
+    };
+    const result = await uploadEvents(uploadOptions);
+    spinner.succeed(`Uploaded ${result.uploaded} event(s)`);
+    print.dim(`Endpoint: ${result.endpoint}`);
+    print.dim(`Remaining local events: ${result.remaining}`);
+  } catch (error) {
+    spinner.fail(`Upload failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function clear() {
+  const result = clearEvents();
+  print.success(`Cleared ${result.cleared} event(s)`);
+}
+function help() {
+  console.log(`
+${COLORS.cyan}${COLORS.bold}Bootspring Telemetry${COLORS.reset}
+
+${COLORS.cyan}Usage:${COLORS.reset}
+  bootspring telemetry <command> [options]
+
+${COLORS.cyan}Commands:${COLORS.reset}
+  ${COLORS.cyan}status${COLORS.reset}                   Show telemetry status
+  ${COLORS.cyan}list${COLORS.reset}                     List telemetry events
+  ${COLORS.cyan}upload${COLORS.reset}                   Upload events to endpoint
+  ${COLORS.cyan}clear${COLORS.reset}                    Clear local event log
+
+${COLORS.cyan}Options:${COLORS.reset}
+  ${COLORS.cyan}--event <name>${COLORS.reset}           Filter by event name
+  ${COLORS.cyan}--limit <n>${COLORS.reset}              Limit listed/uploaded events
+  ${COLORS.cyan}--endpoint <url>${COLORS.reset}         Upload endpoint override
+  ${COLORS.cyan}--token <value>${COLORS.reset}          Upload bearer token
+  ${COLORS.cyan}--clear${COLORS.reset}                  Clear local events on successful upload
+`);
+}
+async function run(args) {
+  const parsed = parseArgs(args);
+  const command = parsed._[0] ?? 'status';
+  switch (command) {
+    case 'status':
+      showStatus();
+      break;
+    case 'list':
+      listEvents2({
+        event: parsed.event,
+        limit: parsed.limit ? Number(parsed.limit) : void 0
+      });
+      break;
+    case 'upload':
+      await upload({
+        endpoint: parsed.endpoint,
+        token: parsed.token,
+        event: parsed.event,
+        limit: parsed.limit ? Number(parsed.limit) : void 0,
+        clear: Boolean(parsed.clear)
+      });
+      break;
+    case 'clear':
+      clear();
+      break;
+    case 'help':
+    case '--help':
+    case '-h':
+      help();
+      break;
+    default:
+      print.error(`Unknown telemetry command: ${command}`);
+      help();
+  }
+}
+
+// src/cli/dashboard.ts
+var dashboard_exports = {};
+__export(dashboard_exports, {
+  run: () => run2
+});
+init_cjs_shims();
+const import_child_process = require('child_process');
+init_auth();
+const DASHBOARD_URL = 'https://bootspring.com/dashboard';
+const colors = {
+  reset: '\x1B[0m',
+  bold: '\x1B[1m',
+  dim: '\x1B[2m',
+  green: '\x1B[32m',
+  yellow: '\x1B[33m',
+  cyan: '\x1B[36m'
+};
+function openBrowser(url) {
+  const platform2 = process.platform;
+  let command;
+  if (platform2 === 'darwin') {
+    command = `open "${url}"`;
+  } else if (platform2 === 'win32') {
+    command = `start "" "${url}"`;
+  } else {
+    command = `xdg-open "${url}"`;
+  }
+  (0, import_child_process.exec)(command, (error) => {
+    if (error) {
+      console.log(`${colors.dim}Could not open browser automatically.${colors.reset}`);
+      console.log(`${colors.dim}Please visit: ${url}${colors.reset}`);
+    }
+  });
+}
+function openDashboard() {
+  console.log(`
+${colors.cyan}${colors.bold}\u26A1 Bootspring Dashboard${colors.reset}`);
+  if (!isAuthenticated()) {
+    console.log(`
+${colors.yellow}You are not logged in.${colors.reset}`);
+    console.log(`${colors.dim}Run 'bootspring auth login' first to access the dashboard.${colors.reset}
+`);
+    console.log(`${colors.dim}Opening login page...${colors.reset}`);
+    openBrowser('https://bootspring.com/login');
+    return;
+  }
+  const user = getUser();
+  console.log(`
+${colors.dim}Opening dashboard for ${user?.email ?? 'unknown'}...${colors.reset}`);
+  const token = getToken();
+  let url = DASHBOARD_URL;
+  if (token) {
+    url = `${DASHBOARD_URL}?token=${encodeURIComponent(token)}`;
+  }
+  openBrowser(url);
+  console.log(`
+${colors.green}\u2713 Dashboard opened in browser${colors.reset}`);
+  console.log(`${colors.dim}URL: ${DASHBOARD_URL}${colors.reset}
+`);
+}
+function showHelp() {
+  console.log(`
+${colors.cyan}${colors.bold}\u26A1 Bootspring Dashboard${colors.reset}
+${colors.dim}Cloud-based project dashboard${colors.reset}
+
+${colors.bold}Usage:${colors.reset}
+  bootspring dashboard
+
+${colors.bold}Description:${colors.reset}
+  Opens the Bootspring cloud dashboard in your browser.
+
+  The dashboard provides:
+  - Real-time project context sync
+  - Usage analytics and billing
+  - Team management (Team tier)
+  - API key management
+
+${colors.bold}Notes:${colors.reset}
+  - You must be logged in (bootspring auth login)
+  - Dashboard is available at https://bootspring.com/dashboard
+  - Pro tier required for full dashboard features
+`);
+}
+async function run2(args) {
+  const subcommand = args[0];
+  if (subcommand === 'help' || subcommand === '-h' || subcommand === '--help') {
+    showHelp();
+    return;
+  }
+  openDashboard();
+}
+
+// src/cli/generate.ts
+var generate_exports = {};
+__export(generate_exports, {
+  generateClaudeMd: () => generateClaudeMd,
+  run: () => run3
+});
+init_cjs_shims();
+const path7 = __toESM(require('path'));
+
+// src/core/config.ts
+init_cjs_shims();
+const fs5 = __toESM(require('fs'));
+const path5 = __toESM(require('path'));
+const import_zod = require('zod');
+const BasePluginSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(false),
+  provider: import_zod.z.string().optional(),
+  features: import_zod.z.array(import_zod.z.string()).optional().default([])
+}).passthrough();
+const AuthPluginSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(false),
+  provider: import_zod.z.enum(['clerk', 'nextauth', 'auth0', 'supabase', 'jwt', 'custom']).optional(),
+  features: import_zod.z.array(import_zod.z.enum([
+    'social_login',
+    'email_password',
+    'magic_link',
+    'sso',
+    'mfa',
+    'rbac',
+    'passwordless'
+  ])).optional().default([])
+}).passthrough();
+const PaymentsPluginSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(false),
+  provider: import_zod.z.enum(['stripe', 'paddle', 'lemonsqueezy', 'paypal', 'custom']).optional(),
+  features: import_zod.z.array(import_zod.z.enum([
+    'checkout',
+    'subscriptions',
+    'invoices',
+    'usage_billing',
+    'trials',
+    'coupons'
+  ])).optional().default([])
+}).passthrough();
+const DatabasePluginSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(true),
+  provider: import_zod.z.enum(['prisma', 'drizzle', 'typeorm', 'kysely', 'custom']).optional(),
+  features: import_zod.z.array(import_zod.z.enum([
+    'migrations',
+    'transactions',
+    'seeding',
+    'multi_tenant',
+    'full_text_search',
+    'soft_delete'
+  ])).optional().default([])
+}).passthrough();
+const TestingPluginSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(true),
+  provider: import_zod.z.enum(['vitest', 'jest', 'playwright', 'cypress', 'custom']).optional(),
+  features: import_zod.z.array(import_zod.z.enum([
+    'unit',
+    'integration',
+    'e2e',
+    'coverage',
+    'snapshot',
+    'mocking'
+  ])).optional().default([])
+}).passthrough();
+const SecurityPluginSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(true),
+  provider: import_zod.z.string().optional(),
+  features: import_zod.z.array(import_zod.z.enum([
+    'input_validation',
+    'rate_limiting',
+    'csrf',
+    'xss',
+    'sql_injection',
+    'audit',
+    'rbac',
+    'encryption',
+    'secrets_management'
+  ])).optional().default([])
+}).passthrough();
+const AIPluginSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(false),
+  provider: import_zod.z.enum(['anthropic', 'openai', 'google', 'cohere', 'custom']).optional(),
+  features: import_zod.z.array(import_zod.z.enum([
+    'streaming',
+    'tool_use',
+    'embeddings',
+    'rag',
+    'agents',
+    'vision'
+  ])).optional().default([])
+}).passthrough();
+const EmailPluginSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(false),
+  provider: import_zod.z.enum(['resend', 'sendgrid', 'postmark', 'ses', 'mailgun', 'custom']).optional(),
+  features: import_zod.z.array(import_zod.z.enum([
+    'transactional',
+    'marketing',
+    'templates',
+    'tracking'
+  ])).optional().default([])
+}).passthrough();
+const AnalyticsPluginSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(false),
+  provider: import_zod.z.enum(['posthog', 'amplitude', 'mixpanel', 'google_analytics', 'custom']).optional(),
+  features: import_zod.z.array(import_zod.z.enum([
+    'page_views',
+    'events',
+    'user_tracking',
+    'funnels',
+    'experiments'
+  ])).optional().default([])
+}).passthrough();
+const MonitoringPluginSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(false),
+  provider: import_zod.z.enum(['sentry', 'datadog', 'newrelic', 'logrocket', 'custom']).optional(),
+  features: import_zod.z.array(import_zod.z.enum([
+    'error_tracking',
+    'performance',
+    'logs',
+    'alerts',
+    'apm'
+  ])).optional().default([])
+}).passthrough();
+const PluginsSchema = import_zod.z.object({
+  auth: AuthPluginSchema.optional(),
+  payments: PaymentsPluginSchema.optional(),
+  database: DatabasePluginSchema.optional(),
+  testing: TestingPluginSchema.optional(),
+  security: SecurityPluginSchema.optional(),
+  ai: AIPluginSchema.optional(),
+  email: EmailPluginSchema.optional(),
+  analytics: AnalyticsPluginSchema.optional(),
+  monitoring: MonitoringPluginSchema.optional()
+}).catchall(BasePluginSchema);
+const AgentConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(true),
+  expertise: import_zod.z.array(import_zod.z.string()).optional(),
+  customInstructions: import_zod.z.string().optional(),
+  priority: import_zod.z.enum(['high', 'medium', 'low']).optional().default('medium')
+}).passthrough();
+const AgentsConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.record(import_zod.z.string(), import_zod.z.boolean()).optional(),
+  custom: import_zod.z.record(import_zod.z.string(), AgentConfigSchema).optional(),
+  defaults: import_zod.z.array(import_zod.z.string()).optional(),
+  settings: import_zod.z.object({
+    maxConcurrent: import_zod.z.number().int().min(1).max(10).optional().default(3),
+    timeout: import_zod.z.number().int().min(1e3).max(3e5).optional().default(6e4),
+    verbose: import_zod.z.boolean().optional().default(false)
+  }).optional()
+}).passthrough();
+const SkillConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional().default(true),
+  tier: import_zod.z.enum(['free', 'pro', 'premium']).optional().default('free'),
+  category: import_zod.z.string().optional(),
+  maxChars: import_zod.z.number().int().min(100).optional()
+}).passthrough();
+const SkillsConfigSchema = import_zod.z.object({
+  categories: import_zod.z.record(import_zod.z.string(), import_zod.z.boolean()).optional(),
+  custom: import_zod.z.record(import_zod.z.string(), SkillConfigSchema).optional(),
+  external: import_zod.z.object({
+    enabled: import_zod.z.boolean().optional().default(false),
+    manifestUrl: import_zod.z.string().url().optional(),
+    cacheDir: import_zod.z.string().optional(),
+    requireSignature: import_zod.z.boolean().optional().default(false)
+  }).optional(),
+  settings: import_zod.z.object({
+    defaultMaxChars: import_zod.z.number().int().min(100).optional().default(5e4),
+    summaryByDefault: import_zod.z.boolean().optional().default(false),
+    includeExternal: import_zod.z.boolean().optional().default(false)
+  }).optional()
+}).passthrough();
+const WorkflowPhaseSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1, 'Phase name is required'),
+  agents: import_zod.z.array(import_zod.z.string()).min(1, 'At least one agent is required'),
+  duration: import_zod.z.string().optional(),
+  parallel: import_zod.z.boolean().optional().default(false),
+  description: import_zod.z.string().optional()
+}).passthrough();
+const WorkflowConfigSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1, 'Workflow name is required'),
+  description: import_zod.z.string().optional(),
+  tier: import_zod.z.enum(['free', 'pro']).optional().default('free'),
+  pack: import_zod.z.string().optional(),
+  outcomes: import_zod.z.array(import_zod.z.string()).optional(),
+  completionSignals: import_zod.z.array(import_zod.z.string()).optional(),
+  phases: import_zod.z.array(WorkflowPhaseSchema).min(1, 'At least one phase is required')
+}).passthrough();
+const WorkflowsConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.record(import_zod.z.string(), import_zod.z.boolean()).optional(),
+  custom: import_zod.z.record(import_zod.z.string(), WorkflowConfigSchema).optional(),
+  default: import_zod.z.string().optional(),
+  settings: import_zod.z.object({
+    autoAdvance: import_zod.z.boolean().optional().default(true),
+    pauseBetweenPhases: import_zod.z.boolean().optional().default(false),
+    trackSignals: import_zod.z.boolean().optional().default(true),
+    emitTelemetry: import_zod.z.boolean().optional().default(true)
+  }).optional()
+}).passthrough();
+const QualityCheckSchema = import_zod.z.union([
+  import_zod.z.boolean(),
+  import_zod.z.object({
+    enabled: import_zod.z.boolean().optional().default(true),
+    checks: import_zod.z.array(import_zod.z.enum([
+      'lint',
+      'typecheck',
+      'test',
+      'build',
+      'security',
+      'coverage',
+      'format'
+    ])).optional()
+  })
+]);
+const QualityConfigSchema = import_zod.z.object({
+  preCommit: QualityCheckSchema.optional().default(true),
+  prePush: QualityCheckSchema.optional().default(false),
+  preDeploy: QualityCheckSchema.optional(),
+  strictMode: import_zod.z.boolean().optional().default(false),
+  coverage: import_zod.z.object({
+    statements: import_zod.z.number().min(0).max(100).optional(),
+    branches: import_zod.z.number().min(0).max(100).optional(),
+    functions: import_zod.z.number().min(0).max(100).optional(),
+    lines: import_zod.z.number().min(0).max(100).optional()
+  }).optional()
+}).passthrough();
+const ContextConfigSchema = import_zod.z.object({
+  includeEnvVars: import_zod.z.boolean().optional().default(true),
+  includeTechStack: import_zod.z.boolean().optional().default(true),
+  includePlugins: import_zod.z.boolean().optional().default(true),
+  includeGitInfo: import_zod.z.boolean().optional().default(true),
+  includeTodos: import_zod.z.boolean().optional().default(true),
+  includeLearnings: import_zod.z.boolean().optional().default(true),
+  customSections: import_zod.z.array(import_zod.z.object({
+    title: import_zod.z.string(),
+    content: import_zod.z.string()
+  })).optional().default([]),
+  maxSize: import_zod.z.number().int().min(1e3).optional()
+}).passthrough();
+const PathsConfigSchema = import_zod.z.object({
+  context: import_zod.z.string().optional().default('CLAUDE.md'),
+  config: import_zod.z.string().optional().default('bootspring.config.js'),
+  todo: import_zod.z.string().optional().default('todo.md'),
+  roadmap: import_zod.z.string().optional().default('ROADMAP.md'),
+  changelog: import_zod.z.string().optional().default('CHANGELOG.md'),
+  state: import_zod.z.string().optional().default('.bootspring')
+}).passthrough();
+const DashboardConfigSchema = import_zod.z.object({
+  port: import_zod.z.number().int().min(1024).max(65535).optional().default(3456),
+  autoOpen: import_zod.z.boolean().optional().default(false),
+  host: import_zod.z.string().optional().default('localhost'),
+  theme: import_zod.z.enum(['light', 'dark', 'system']).optional().default('system')
+}).passthrough();
+const ProjectConfigSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1, 'Project name is required'),
+  description: import_zod.z.string().optional().default(''),
+  version: import_zod.z.string().regex(/^\d+\.\d+\.\d+/, 'Version must be semver format').optional().default('1.0.0'),
+  author: import_zod.z.string().optional(),
+  license: import_zod.z.string().optional(),
+  repository: import_zod.z.string().url().optional()
+}).passthrough();
+const StackConfigSchema = import_zod.z.object({
+  framework: import_zod.z.enum([
+    'nextjs',
+    'remix',
+    'nuxt',
+    'sveltekit',
+    'astro',
+    'express',
+    'fastify',
+    'hono',
+    'custom'
+  ]).optional(),
+  language: import_zod.z.enum(['typescript', 'javascript']).optional(),
+  database: import_zod.z.enum(['postgresql', 'mysql', 'mongodb', 'sqlite', 'supabase', 'planetscale', 'none']).optional(),
+  hosting: import_zod.z.enum([
+    'vercel',
+    'railway',
+    'render',
+    'fly',
+    'aws',
+    'gcp',
+    'azure',
+    'cloudflare',
+    'self-hosted',
+    'custom'
+  ]).optional()
+}).passthrough();
+const ConfigSchema = import_zod.z.object({
+  project: ProjectConfigSchema.optional(),
+  stack: StackConfigSchema.optional(),
+  plugins: PluginsSchema.optional(),
+  agents: AgentsConfigSchema.optional(),
+  skills: SkillsConfigSchema.optional(),
+  workflows: WorkflowsConfigSchema.optional(),
+  dashboard: DashboardConfigSchema.optional(),
+  quality: QualityConfigSchema.optional(),
+  context: ContextConfigSchema.optional(),
+  paths: PathsConfigSchema.optional(),
+  mcp: import_zod.z.object({
+    enabled: import_zod.z.boolean().optional().default(false),
+    servers: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
+      command: import_zod.z.string(),
+      args: import_zod.z.array(import_zod.z.string()).optional(),
+      env: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+    })).optional()
+  }).optional()
+}).passthrough();
+function formatValidationErrors(zodError) {
+  return zodError.issues.map((issue) => {
+    const path9 = issue.path.join('.');
+    const prefix = path9 ? `${path9}: ` : '';
+    switch (issue.code) {
+      case 'invalid_type':
+        return `${prefix}Expected ${issue.expected}, received ${issue.received}`;
+      case 'invalid_enum_value':
+        return `${prefix}Invalid value "${issue.received}". Expected one of: ${issue.options.join(', ')}`;
+      case 'too_small':
+        if (issue.type === 'string') {
+          return `${prefix}String must contain at least ${issue.minimum} character(s)`;
+        }
+        if (issue.type === 'array') {
+          return `${prefix}Array must contain at least ${issue.minimum} element(s)`;
+        }
+        return `${prefix}Value must be greater than or equal to ${issue.minimum}`;
+      case 'too_big':
+        return `${prefix}Value must be less than or equal to ${issue.maximum}`;
+      case 'invalid_string':
+        if (issue.validation === 'url') {
+          return `${prefix}Invalid URL format`;
+        }
+        if (issue.validation === 'regex') {
+          return `${prefix}Invalid format`;
+        }
+        return `${prefix}${issue.message}`;
+      default:
+        return `${prefix}${issue.message}`;
+    }
+  });
+}
+const sectionSchemas = {
+  project: ProjectConfigSchema,
+  stack: StackConfigSchema,
+  plugins: PluginsSchema,
+  agents: AgentsConfigSchema,
+  skills: SkillsConfigSchema,
+  workflows: WorkflowsConfigSchema,
+  dashboard: DashboardConfigSchema,
+  quality: QualityConfigSchema,
+  context: ContextConfigSchema,
+  paths: PathsConfigSchema
+};
+function validateSection(section, data) {
+  const schema = sectionSchemas[section];
+  if (!schema) {
+    return {
+      valid: false,
+      errors: [`Unknown configuration section: ${section}`],
+      data: null
+    };
+  }
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return {
+      valid: true,
+      errors: [],
+      data: result.data
+    };
+  }
+  return {
+    valid: false,
+    errors: formatValidationErrors(result.error),
+    data: null
+  };
+}
+const DEFAULT_CONFIG = {
+  project: {
+    name: 'My Project',
+    description: '',
+    version: '1.0.0'
+  },
+  stack: {
+    framework: 'nextjs',
+    language: 'typescript',
+    database: 'postgresql',
+    hosting: 'vercel'
+  },
+  plugins: {
+    auth: { enabled: false, provider: 'clerk' },
+    payments: { enabled: false, provider: 'stripe' },
+    database: { enabled: true, provider: 'prisma' },
+    testing: { enabled: true, provider: 'vitest' },
+    security: { enabled: true },
+    ai: { enabled: false }
+  },
+  dashboard: {
+    port: 3456,
+    autoOpen: false
+  },
+  quality: {
+    preCommit: true,
+    prePush: false,
+    strictMode: false
+  },
+  paths: {
+    context: 'CLAUDE.md',
+    config: 'bootspring.config.js',
+    todo: 'todo.md'
+  }
+};
+const CONFIG_FILES = [
+  'bootspring.config.js',
+  'bootspring.config.mjs',
+  'bootspring.config.json',
+  '.bootspringrc',
+  '.bootspringrc.js',
+  '.bootspringrc.json'
+];
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (Array.isArray(sourceValue)) {
+      result[key] = [...sourceValue];
+    } else if (sourceValue !== null && typeof sourceValue === 'object' && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === 'object' && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function findProjectRoot() {
+  let dir = process.cwd();
+  const root = path5.parse(dir).root;
+  while (dir !== root) {
+    if (fs5.existsSync(path5.join(dir, 'package.json')) || fs5.existsSync(path5.join(dir, 'bootspring.config.js')) || fs5.existsSync(path5.join(dir, '.git'))) {
+      return dir;
+    }
+    dir = path5.dirname(dir);
+  }
+  return process.cwd();
+}
+function findConfigFile(projectRoot) {
+  for (const filename of CONFIG_FILES) {
+    const filepath = path5.join(projectRoot, filename);
+    if (fs5.existsSync(filepath)) {
+      return filepath;
+    }
+  }
+  return null;
+}
+function load(projectRoot = null) {
+  const root = projectRoot ?? findProjectRoot();
+  const configPath = findConfigFile(root);
+  let userConfig = {};
+  if (configPath) {
+    try {
+      if (configPath.endsWith('.json') || configPath.endsWith('.bootspringrc')) {
+        const content = fs5.readFileSync(configPath, 'utf-8');
+        userConfig = JSON.parse(content);
+      } else {
+        delete require.cache[require.resolve(configPath)];
+        userConfig = require(configPath);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`Warning: Could not load config from ${configPath}: ${message}`);
+    }
+  }
+  const config = deepMerge(DEFAULT_CONFIG, userConfig);
+  config._projectRoot = root;
+  config._configPath = configPath;
+  config._bootspringDir = path5.join(root, '.bootspring');
+  return config;
+}
+function validate(config, options = {}) {
+  const configToValidate = { ...config };
+  delete configToValidate._projectRoot;
+  delete configToValidate._configPath;
+  delete configToValidate._bootspringDir;
+  delete configToValidate._validation;
+  const errors = [];
+  const warnings = [];
+  if (options.sections && options.sections.length > 0) {
+    let allValid = true;
+    const validatedData = {};
+    for (const section of options.sections) {
+      const sectionValue = configToValidate[section];
+      if (sectionValue !== void 0) {
+        const result2 = validateSection(section, sectionValue);
+        if (!result2.valid) {
+          allValid = false;
+          errors.push(...result2.errors);
+        } else {
+          validatedData[section] = result2.data;
+        }
+      }
+    }
+    return {
+      valid: allValid,
+      errors,
+      warnings,
+      data: allValid ? validatedData : null
+    };
+  }
+  const result = ConfigSchema.safeParse(configToValidate);
+  if (result.success) {
+    return {
+      valid: true,
+      errors: [],
+      warnings,
+      data: result.data
+    };
+  }
+  return {
+    valid: false,
+    errors: formatValidationErrors(result.error),
+    warnings,
+    data: null
+  };
+}
+
+// src/core/context.ts
+init_cjs_shims();
+const path6 = __toESM(require('path'));
+function get(options = {}) {
+  const cfg = options.config ?? load();
+  const projectRoot = cfg._projectRoot ?? process.cwd();
+  const context = {
+    project: cfg.project,
+    stack: cfg.stack,
+    plugins: getEnabledPlugins(cfg),
+    files: getProjectFiles(projectRoot),
+    git: getGitInfo(projectRoot),
+    state: getProjectState(projectRoot, cfg),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return context;
+}
+function getEnabledPlugins(cfg) {
+  const enabled = {};
+  const plugins = cfg.plugins ?? {};
+  for (const [name, plugin] of Object.entries(plugins)) {
+    if (plugin && plugin.enabled !== false) {
+      enabled[name] = {
+        provider: plugin.provider ?? 'default',
+        features: plugin.features ?? []
+      };
+    }
+  }
+  return enabled;
+}
+function getProjectFiles(projectRoot) {
+  const files = {
+    hasPackageJson: fileExists(path6.join(projectRoot, 'package.json')),
+    hasTsConfig: fileExists(path6.join(projectRoot, 'tsconfig.json')),
+    hasClaudeMd: fileExists(path6.join(projectRoot, 'CLAUDE.md')),
+    hasBootspringConfig: fileExists(path6.join(projectRoot, 'bootspring.config.js')),
+    hasTodoMd: fileExists(path6.join(projectRoot, 'todo.md')),
+    hasGit: fileExists(path6.join(projectRoot, '.git')),
+    hasSrcDir: fileExists(path6.join(projectRoot, 'src')),
+    hasAppDir: fileExists(path6.join(projectRoot, 'app')),
+    hasPagesDir: fileExists(path6.join(projectRoot, 'pages')),
+    structure: 'flat'
+  };
+  if (files.hasAppDir) {
+    files.structure = 'app-router';
+  } else if (files.hasPagesDir) {
+    files.structure = 'pages-router';
+  } else if (files.hasSrcDir) {
+    files.structure = 'src-based';
+  }
+  return files;
+}
+function getGitInfo(projectRoot) {
+  const gitDir = path6.join(projectRoot, '.git');
+  if (!fileExists(gitDir)) {
+    return { initialized: false };
+  }
+  const info = { initialized: true };
+  const headPath = path6.join(gitDir, 'HEAD');
+  if (fileExists(headPath)) {
+    const head = readFile(headPath);
+    if (head) {
+      const trimmedHead = head.trim();
+      if (trimmedHead.startsWith('ref: refs/heads/')) {
+        info.branch = trimmedHead.replace('ref: refs/heads/', '');
+      }
+    }
+  }
+  const configPath = path6.join(gitDir, 'config');
+  if (fileExists(configPath)) {
+    const gitConfig = readFile(configPath);
+    if (gitConfig) {
+      info.hasRemote = gitConfig.includes('[remote "origin"]');
+    }
+  }
+  return info;
+}
+function getProjectState(projectRoot, cfg) {
+  const state = {
+    phase: 'unknown',
+    health: 'unknown',
+    todos: 0,
+    lastGenerated: null
+  };
+  const todoPath = path6.join(projectRoot, cfg.paths?.todo ?? 'todo.md');
+  if (fileExists(todoPath)) {
+    const content = readFile(todoPath);
+    if (content) {
+      const todoMatches = content.match(/- \[ \]/g);
+      state.todos = todoMatches ? todoMatches.length : 0;
+    }
+  }
+  const claudePath = path6.join(projectRoot, cfg.paths?.context ?? 'CLAUDE.md');
+  if (fileExists(claudePath)) {
+    state.lastGenerated = getFileTime(claudePath);
+  }
+  const loadedCfg = cfg;
+  if (!loadedCfg._configPath) {
+    state.phase = 'uninitialized';
+  } else if (!state.lastGenerated) {
+    state.phase = 'initialized';
+  } else {
+    state.phase = 'active';
+  }
+  const issues = [];
+  if (!fileExists(path6.join(projectRoot, 'package.json'))) {
+    issues.push('missing-package-json');
+  }
+  if (!loadedCfg._configPath) {
+    issues.push('missing-config');
+  }
+  if (!state.lastGenerated) {
+    issues.push('missing-context');
+  }
+  if (issues.length === 0) {
+    state.health = 'good';
+  } else if (issues.length <= 2) {
+    state.health = 'fair';
+  } else {
+    state.health = 'needs-attention';
+  }
+  state.issues = issues;
+  return state;
+}
+function validate2(options = {}) {
+  const cfg = options.config ?? load();
+  const projectRoot = cfg._projectRoot ?? process.cwd();
+  const checks = [];
+  let score = 0;
+  const maxScore = 10;
+  if (cfg._configPath) {
+    checks.push({ name: 'Configuration', status: 'pass', message: 'bootspring.config.js found' });
+    score += 2;
+  } else {
+    checks.push({ name: 'Configuration', status: 'fail', message: 'bootspring.config.js missing' });
+  }
+  const claudePath = path6.join(projectRoot, cfg.paths?.context ?? 'CLAUDE.md');
+  if (fileExists(claudePath)) {
+    checks.push({ name: 'AI Context', status: 'pass', message: 'CLAUDE.md exists' });
+    score += 2;
+  } else {
+    checks.push({ name: 'AI Context', status: 'fail', message: 'CLAUDE.md missing - run bootspring generate' });
+  }
+  if (fileExists(path6.join(projectRoot, 'package.json'))) {
+    checks.push({ name: 'Package', status: 'pass', message: 'package.json found' });
+    score += 1;
+  } else {
+    checks.push({ name: 'Package', status: 'warn', message: 'package.json missing' });
+  }
+  if (fileExists(path6.join(projectRoot, '.git'))) {
+    checks.push({ name: 'Git', status: 'pass', message: 'Git repository initialized' });
+    score += 1;
+  } else {
+    checks.push({ name: 'Git', status: 'warn', message: 'Git not initialized' });
+  }
+  if (cfg.stack?.language === 'typescript') {
+    if (fileExists(path6.join(projectRoot, 'tsconfig.json'))) {
+      checks.push({ name: 'TypeScript', status: 'pass', message: 'tsconfig.json found' });
+      score += 1;
+    } else {
+      checks.push({ name: 'TypeScript', status: 'fail', message: 'tsconfig.json missing for TypeScript project' });
+    }
+  } else {
+    score += 1;
+  }
+  const configValidation = validate(cfg);
+  if (configValidation.valid) {
+    checks.push({ name: 'Config Validation', status: 'pass', message: 'Configuration is valid' });
+    score += 2;
+  } else {
+    checks.push({ name: 'Config Validation', status: 'fail', message: configValidation.errors.join(', ') });
+  }
+  if (fileExists(path6.join(projectRoot, cfg.paths?.todo ?? 'todo.md'))) {
+    checks.push({ name: 'Todo Tracking', status: 'pass', message: 'todo.md exists' });
+    score += 1;
+  } else {
+    checks.push({ name: 'Todo Tracking', status: 'fail', message: 'todo.md not found' });
+  }
+  return {
+    valid: score >= maxScore * 0.6,
+    score,
+    maxScore,
+    percentage: Math.round(score / maxScore * 100),
+    checks
+  };
+}
+
+// src/cli/generate.ts
+function generateClaudeMd(cfg, ctx) {
+  const date = formatDate();
+  const sections = [];
+  sections.push(`# ${cfg.project?.name ?? 'Project'} - AI Context
+
+**Generated by**: Bootspring v1.0.0
+**Last Updated**: ${date}
+**Status**: ${ctx.state.phase}
+**Health**: ${ctx.state.health}
+
+---`);
+  sections.push(`## Project Overview
+
+${cfg.project?.description ?? 'A modern web application built with Bootspring.'}
+
+---`);
+  sections.push(`## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | ${cfg.stack?.framework ?? 'unknown'} |
+| Language | ${cfg.stack?.language ?? 'unknown'} |
+| Database | ${cfg.stack?.database ?? 'unknown'} |
+| Hosting | ${cfg.stack?.hosting ?? 'unknown'} |
+
+---`);
+  const plugins = cfg.plugins ?? {};
+  const enabledPlugins = Object.entries(plugins).filter(([_name, p]) => p && p.enabled !== false);
+  if (enabledPlugins.length > 0) {
+    const pluginSections = enabledPlugins.map(([name, plugin]) => {
+      const pluginData = plugin;
+      return `### ${name.charAt(0).toUpperCase() + name.slice(1)}
+- **Provider**: ${pluginData.provider ?? 'default'}
+- **Features**: ${(pluginData.features ?? []).join(', ') || 'default'}`;
+    });
+    sections.push(`## Enabled Plugins
+
+${pluginSections.join('\n\n')}
+
+---`);
+  }
+  sections.push(`## Bootspring Commands
+
+Quick commands for your AI assistant:
+
+### Todo Management
+\`\`\`bash
+bootspring todo add "task"    # Add a new todo
+bootspring todo list          # List all todos
+bootspring todo done <id>     # Mark as complete
+bootspring todo clear         # Clear completed
+\`\`\`
+
+### Agents & Skills
+\`\`\`bash
+bootspring agent list         # List available agents
+bootspring agent invoke <n>   # Get specialized help
+bootspring skill search <q>   # Find code patterns
+bootspring skill show <name>  # View a skill
+\`\`\`
+
+### Project Tools
+\`\`\`bash
+bootspring dashboard          # Start real-time dashboard
+bootspring generate           # Regenerate this context
+bootspring quality pre-commit # Run quality checks
+bootspring context validate   # Validate project setup
+\`\`\`
+
+---`);
+  const issuesText = ctx.state.issues && ctx.state.issues.length > 0 ? `
+- **Issues**: ${ctx.state.issues.join(', ')}` : '';
+  sections.push(`## Current State
+
+- **Phase**: ${ctx.state.phase}
+- **Health**: ${ctx.state.health}
+- **Open Todos**: ${ctx.state.todos}${issuesText}
+
+---`);
+  if (ctx.git.initialized) {
+    sections.push(`## Git Repository
+
+- **Branch**: ${ctx.git.branch ?? 'unknown'}
+- **Remote**: ${ctx.git.hasRemote ? 'configured' : 'not configured'}
+
+---`);
+    try {
+      const gitMemory = require_git_memory();
+      const loadedCfg = cfg;
+      const { learnings } = gitMemory.extractLearnings({
+        limit: 30,
+        since: '2 months ago',
+        cwd: loadedCfg._projectRoot ?? process.cwd()
+      });
+      if (learnings && learnings.length > 0) {
+        const learningsSection = gitMemory.toCompactSummary(learnings, { maxItems: 12 });
+        sections.push(learningsSection + '\n---');
+      }
+    } catch {
+    }
+  }
+  sections.push(`## Project Structure
+
+- **Structure Type**: ${ctx.files.structure}
+- **Has TypeScript**: ${ctx.files.hasTsConfig ? 'yes' : 'no'}
+- **Has Package.json**: ${ctx.files.hasPackageJson ? 'yes' : 'no'}
+
+---`);
+  const language = cfg.stack?.language === 'typescript' ? 'TypeScript' : 'JavaScript';
+  sections.push(`## Development Guidelines
+
+### Code Style
+- Use ${language} for all new code
+- Follow existing naming conventions in the codebase
+- Keep files focused and under 300 lines when possible
+
+### Best Practices
+- Use Server Components by default (if Next.js)
+- Prefer Server Actions over API routes for mutations
+- Use Zod for all input validation
+- Never expose API keys to client-side code
+- Write tests for new features
+
+### Git Commits
+- Use conventional commit format: \`feat:\`, \`fix:\`, \`docs:\`, \`refactor:\`
+- Keep commits focused and atomic
+- **Never add Co-Authored-By or AI attribution to commits**
+- Never commit sensitive data or API keys
+
+---`);
+  if (cfg.customInstructions) {
+    sections.push(`## Custom Instructions
+
+${cfg.customInstructions}
+
+---`);
+  }
+  sections.push(`---
+
+*Generated by [Bootspring](https://bootspring.com) - Development scaffolding with intelligence*
+`);
+  return sections.join('\n\n');
+}
+async function run3(args) {
+  const parsedArgs = parseArgs(args);
+  const full = parsedArgs.full || parsedArgs.f;
+  console.log(`
+${COLORS.cyan}${COLORS.bold}\u26A1 Bootspring Generate${COLORS.reset}
+${COLORS.dim}Regenerating AI context...${COLORS.reset}
+`);
+  const cfg = load();
+  if (!cfg._configPath) {
+    print.error('No bootspring.config.js found');
+    print.dim('Run "bootspring init" first to initialize your project');
+    return;
+  }
+  const ctx = get({ config: cfg });
+  const claudePath = path7.join(cfg._projectRoot ?? process.cwd(), cfg.paths?.context ?? 'CLAUDE.md');
+  const spinner = createSpinner('Generating CLAUDE.md').start();
+  try {
+    const content = generateClaudeMd(cfg, ctx);
+    writeFile(claudePath, content);
+    spinner.succeed('Generated CLAUDE.md');
+  } catch (error) {
+    spinner.fail(`Failed to generate CLAUDE.md: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+  const todoPath = path7.join(cfg._projectRoot ?? process.cwd(), cfg.paths?.todo ?? 'todo.md');
+  if (!fileExists(todoPath)) {
+    const todoSpinner = createSpinner('Generating todo.md').start();
+    const todoContent = `# ${cfg.project?.name ?? 'Project'} - Todo List
+
+> Last updated: ${formatDate()}
+
+## In Progress
+
+## Pending
+
+- [ ] Review generated context
+- [ ] Configure environment variables
+
+## Completed
+
+`;
+    writeFile(todoPath, todoContent);
+    todoSpinner.succeed('Generated todo.md');
+  }
+  const validation = validate2({ config: cfg });
+  console.log(`
+${COLORS.bold}Context Validation${COLORS.reset}
+`);
+  for (const check of validation.checks) {
+    const icon = check.status === 'pass' ? COLORS.green + '\u2713' : check.status === 'fail' ? COLORS.red + '\u2717' : check.status === 'warn' ? COLORS.yellow + '\u26A0' : COLORS.dim + '\u2139';
+    console.log(`  ${icon}${COLORS.reset} ${check.name}: ${COLORS.dim}${check.message}${COLORS.reset}`);
+  }
+  console.log(`
+${COLORS.bold}Score:${COLORS.reset} ${validation.score}/${validation.maxScore} (${validation.percentage}%)
+`);
+  if (validation.valid) {
+    print.success('Context is valid and ready for AI assistants');
+  } else {
+    print.warning('Context has some issues - review the checks above');
+  }
+  if (full) {
+    console.log(`
+${COLORS.bold}Full Generation${COLORS.reset}
+`);
+    const mcpPath = path7.join(cfg._projectRoot ?? process.cwd(), '.mcp.json');
+    if (!fileExists(mcpPath)) {
+      const mcpSpinner = createSpinner('Generating .mcp.json').start();
+      const mcpConfig = {
+        mcpServers: {
+          bootspring: {
+            command: 'npx',
+            args: ['bootspring', 'mcp'],
+            env: {}
+          }
+        }
+      };
+      writeFile(mcpPath, JSON.stringify(mcpConfig, null, 2));
+      mcpSpinner.succeed('Generated .mcp.json');
+    }
+    const agentsPath = path7.join(cfg._projectRoot ?? process.cwd(), 'AGENTS.md');
+    const agentsSpinner = createSpinner('Generating AGENTS.md').start();
+    try {
+      const agentsTemplate = require_agents_template();
+      const agentsContent = agentsTemplate.generate(cfg);
+      writeFile(agentsPath, agentsContent);
+      agentsSpinner.succeed('Generated AGENTS.md (Codex, Cursor, Amp, Kilo)');
+    } catch (error) {
+      agentsSpinner.fail(`Failed to generate AGENTS.md: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  console.log(`
+${COLORS.dim}Tip: Run 'bootspring generate --full' to regenerate all files${COLORS.reset}
+`);
+}
+
+// src/cli/todo.ts
+var todo_exports = {};
+__export(todo_exports, {
+  addTodo: () => addTodo,
+  clearCompleted: () => clearCompleted,
+  clearTodos: () => clearTodos,
+  doneTodo: () => doneTodo,
+  listTodos: () => listTodos,
+  markDone: () => markDone,
+  markUndone: () => markUndone,
+  parseTodoFile: () => parseTodoFile,
+  parseTodos: () => parseTodos,
+  removeTodo: () => removeTodo,
+  run: () => run4,
+  undoTodo: () => undoTodo,
+  writeTodoFile: () => writeTodoFile
+});
+init_cjs_shims();
+const fs6 = __toESM(require('fs'));
+const path8 = __toESM(require('path'));
+function parseTodoFile(filePath) {
+  try {
+    const content = fs6.readFileSync(filePath, 'utf-8');
+    const todos = [];
+    const lines = content.split('\n');
+    for (const line of lines) {
+      const match = line.match(/^(\s*)-\s*\[([ xX])\]\s*(.+)$/);
+      if (match && match[2] && match[3]) {
+        todos.push({
+          done: match[2].toLowerCase() === 'x',
+          text: match[3].trim()
+        });
+      }
+    }
+    return todos;
+  } catch {
+    return [];
+  }
+}
+function writeTodoFile(filePath, items) {
+  const lines = ['# Todo', ''];
+  for (const item of items) {
+    const checkbox = item.done ? '[x]' : '[ ]';
+    lines.push(`- ${checkbox} ${item.text}`);
+  }
+  lines.push('');
+  fs6.writeFileSync(filePath, lines.join('\n'), 'utf-8');
+}
+function addTodoUtil(filePath, text) {
+  const todos = parseTodoFile(filePath);
+  todos.push({ done: false, text });
+  writeTodoFile(filePath, todos);
+}
+function markDone(filePath, index) {
+  const todos = parseTodoFile(filePath);
+  if (index >= 0 && index < todos.length) {
+    const todo = todos[index];
+    if (todo) {
+      todo.done = true;
+      writeTodoFile(filePath, todos);
+    }
+  }
+}
+function markUndone(filePath, index) {
+  const todos = parseTodoFile(filePath);
+  if (index >= 0 && index < todos.length) {
+    const todo = todos[index];
+    if (todo) {
+      todo.done = false;
+      writeTodoFile(filePath, todos);
+    }
+  }
+}
+function removeTodoUtil(filePath, index) {
+  const todos = parseTodoFile(filePath);
+  if (index >= 0 && index < todos.length) {
+    todos.splice(index, 1);
+    writeTodoFile(filePath, todos);
+  }
+}
+function clearTodos(filePath, type = 'completed') {
+  const todos = parseTodoFile(filePath);
+  if (type === 'all') {
+    writeTodoFile(filePath, []);
+  } else if (type === 'completed') {
+    const remaining = todos.filter((t) => !t.done);
+    writeTodoFile(filePath, remaining);
+  }
+}
+function listTodosUtil(filePath) {
+  return parseTodoFile(filePath);
+}
+function parseTodos(content) {
+  const todos = [];
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const match = line.match(/^(\s*)-\s*\[([ xX])\]\s*(.+)$/);
+    if (match && match[1] !== void 0 && match[2] && match[3]) {
+      todos.push({
+        index: todos.length + 1,
+        indent: match[1].length,
+        completed: match[2].toLowerCase() === 'x',
+        text: match[3].trim(),
+        line: i
+      });
+    }
+  }
+  return todos;
+}
+function displayTodos(todos, options = {}) {
+  const { showCompleted = true, showIndex = true } = options;
+  const pending = todos.filter((t) => !t.completed);
+  const completed = todos.filter((t) => t.completed);
+  if (pending.length === 0 && completed.length === 0) {
+    print.dim('No todos found. Add one with: bootspring todo add "Your task"');
+    return;
+  }
+  if (pending.length > 0) {
+    console.log(`
+${COLORS.bold}Pending (${pending.length})${COLORS.reset}
+`);
+    for (const todo of pending) {
+      const index = showIndex ? `${COLORS.dim}${String(todo.index).padStart(2)}${COLORS.reset} ` : '';
+      const indent = ' '.repeat(todo.indent);
+      console.log(`${index}${indent}${COLORS.yellow}\u25CB${COLORS.reset} ${todo.text}`);
+    }
+  }
+  if (showCompleted && completed.length > 0) {
+    console.log(`
+${COLORS.bold}Completed (${completed.length})${COLORS.reset}
+`);
+    for (const todo of completed) {
+      const index = showIndex ? `${COLORS.dim}${String(todo.index).padStart(2)}${COLORS.reset} ` : '';
+      const indent = ' '.repeat(todo.indent);
+      console.log(`${index}${indent}${COLORS.green}\u25CF${COLORS.reset} ${COLORS.dim}${todo.text}${COLORS.reset}`);
+    }
+  }
+  console.log();
+}
+function getTodoPath() {
+  const cfg = load();
+  return path8.join(cfg._projectRoot ?? process.cwd(), cfg.paths?.todo ?? 'todo.md');
+}
+function readTodoFile() {
+  const todoPath = getTodoPath();
+  if (!fileExists(todoPath)) {
+    const defaultContent = '# Todo List\n\n## Pending\n\n## Completed\n';
+    writeFile(todoPath, defaultContent);
+    return defaultContent;
+  }
+  return readFile(todoPath) ?? '';
+}
+function saveTodoContent(content) {
+  const todoPath = getTodoPath();
+  writeFile(todoPath, content);
+}
+function listTodosCli(args) {
+  const parsedArgs = parseArgs(args);
+  const content = readTodoFile();
+  const todos = parseTodos(content);
+  console.log(`${COLORS.cyan}${COLORS.bold}\u26A1 Bootspring Todo${COLORS.reset}`);
+  displayTodos(todos, {
+    showCompleted: !parsedArgs.pending,
+    showIndex: true
+  });
+  const pending = todos.filter((t) => !t.completed).length;
+  const completed = todos.filter((t) => t.completed).length;
+  print.dim(`${pending} pending, ${completed} completed`);
+}
+function addTodoCli(args) {
+  const text = args.join(' ').trim();
+  if (!text) {
+    print.error('Please provide a todo text');
+    print.dim('Usage: bootspring todo add "Your task"');
+    return;
+  }
+  const content = readTodoFile();
+  const lines = content.split('\n');
+  let insertIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line && line.match(/^##?\s*(Pending|In Progress|Todo)/i)) {
+      insertIndex = i + 1;
+      while (insertIndex < lines.length && lines[insertIndex]?.trim() === '') {
+        insertIndex++;
+      }
+      break;
+    }
+  }
+  if (insertIndex === -1) {
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i]?.startsWith('#')) {
+        insertIndex = i + 1;
+        break;
+      }
+    }
+  }
+  if (insertIndex === -1) {
+    insertIndex = lines.length;
+  }
+  const newTodo = `- [ ] ${text}`;
+  lines.splice(insertIndex, 0, newTodo);
+  saveTodoContent(lines.join('\n'));
+  print.success(`Added: ${text}`);
+  const todos = parseTodos(lines.join('\n'));
+  const pending = todos.filter((t) => !t.completed).length;
+  print.dim(`${pending} pending todos`);
+}
+function doneTodo(args) {
+  const indexStr = args[0];
+  if (!indexStr) {
+    print.error('Please provide a todo number');
+    print.dim('Usage: bootspring todo done <number>');
+    return;
+  }
+  const index = parseInt(indexStr, 10);
+  if (isNaN(index) || index < 1) {
+    print.error('Invalid todo number');
+    return;
+  }
+  const content = readTodoFile();
+  const todos = parseTodos(content);
+  const todo = todos.find((t) => t.index === index);
+  if (!todo) {
+    print.error(`Todo #${index} not found`);
+    return;
+  }
+  if (todo.completed) {
+    print.warning(`Todo #${index} is already completed`);
+    return;
+  }
+  const lines = content.split('\n');
+  const originalLine = lines[todo.line];
+  if (originalLine) {
+    lines[todo.line] = originalLine.replace('[ ]', '[x]');
+  }
+  saveTodoContent(lines.join('\n'));
+  print.success(`Completed: ${todo.text}`);
+  const remaining = todos.filter((t) => !t.completed && t.index !== index).length;
+  print.dim(`${remaining} pending todos remaining`);
+}
+function undoTodo(args) {
+  const indexStr = args[0];
+  if (!indexStr) {
+    print.error('Please provide a todo number');
+    print.dim('Usage: bootspring todo undo <number>');
+    return;
+  }
+  const index = parseInt(indexStr, 10);
+  if (isNaN(index) || index < 1) {
+    print.error('Invalid todo number');
+    return;
+  }
+  const content = readTodoFile();
+  const todos = parseTodos(content);
+  const todo = todos.find((t) => t.index === index);
+  if (!todo) {
+    print.error(`Todo #${index} not found`);
+    return;
+  }
+  if (!todo.completed) {
+    print.warning(`Todo #${index} is not completed`);
+    return;
+  }
+  const lines = content.split('\n');
+  const originalLine = lines[todo.line];
+  if (originalLine) {
+    lines[todo.line] = originalLine.replace(/\[[xX]\]/, '[ ]');
+  }
+  saveTodoContent(lines.join('\n'));
+  print.success(`Reopened: ${todo.text}`);
+}
+function removeTodoCli(args) {
+  const indexStr = args[0];
+  if (!indexStr) {
+    print.error('Please provide a todo number');
+    print.dim('Usage: bootspring todo remove <number>');
+    return;
+  }
+  const index = parseInt(indexStr, 10);
+  if (isNaN(index) || index < 1) {
+    print.error('Invalid todo number');
+    return;
+  }
+  const content = readTodoFile();
+  const todos = parseTodos(content);
+  const todo = todos.find((t) => t.index === index);
+  if (!todo) {
+    print.error(`Todo #${index} not found`);
+    return;
+  }
+  const lines = content.split('\n');
+  lines.splice(todo.line, 1);
+  saveTodoContent(lines.join('\n'));
+  print.success(`Removed: ${todo.text}`);
+}
+function clearCompleted() {
+  const content = readTodoFile();
+  const todos = parseTodos(content);
+  const completedTodos = todos.filter((t) => t.completed);
+  if (completedTodos.length === 0) {
+    print.info('No completed todos to clear');
+    return;
+  }
+  const lines = content.split('\n');
+  const linesToRemove = completedTodos.map((t) => t.line).sort((a, b) => b - a);
+  for (const lineIndex of linesToRemove) {
+    lines.splice(lineIndex, 1);
+  }
+  saveTodoContent(lines.join('\n'));
+  print.success(`Cleared ${completedTodos.length} completed todos`);
+}
+function showHelp2() {
+  console.log(`
+${COLORS.cyan}${COLORS.bold}\u26A1 Bootspring Todo${COLORS.reset}
+${COLORS.dim}Simple and powerful todo management${COLORS.reset}
+
+${COLORS.bold}Usage:${COLORS.reset}
+  bootspring todo <command> [args]
+
+${COLORS.bold}Commands:${COLORS.reset}
+  ${COLORS.cyan}list${COLORS.reset}              List all todos
+  ${COLORS.cyan}add${COLORS.reset} <text>       Add a new todo
+  ${COLORS.cyan}done${COLORS.reset} <number>    Mark todo as completed
+  ${COLORS.cyan}undo${COLORS.reset} <number>    Reopen a completed todo
+  ${COLORS.cyan}remove${COLORS.reset} <number>  Remove a todo
+  ${COLORS.cyan}clear${COLORS.reset}            Clear all completed todos
+
+${COLORS.bold}Examples:${COLORS.reset}
+  bootspring todo add "Implement user auth"
+  bootspring todo done 1
+  bootspring todo list --pending
+  bootspring todo clear
+`);
+}
+async function run4(args) {
+  const subcommand = args[0] ?? 'list';
+  const subargs = args.slice(1);
+  switch (subcommand) {
+    case 'list':
+    case 'ls':
+      listTodosCli(subargs);
+      break;
+    case 'add':
+    case 'a':
+    case 'new':
+      addTodoCli(subargs);
+      break;
+    case 'done':
+    case 'd':
+    case 'complete':
+    case 'check':
+      doneTodo(subargs);
+      break;
+    case 'undo':
+    case 'u':
+    case 'reopen':
+      undoTodo(subargs);
+      break;
+    case 'remove':
+    case 'rm':
+    case 'delete':
+      removeTodoCli(subargs);
+      break;
+    case 'clear':
+      clearCompleted();
+      break;
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp2();
+      break;
+    default:
+      if (subcommand && !subcommand.startsWith('-')) {
+        addTodoCli([subcommand, ...subargs]);
+      } else {
+        print.error(`Unknown subcommand: ${subcommand}`);
+        showHelp2();
+      }
+  }
+}
+function addTodo(firstArg, secondArg) {
+  if (typeof firstArg === 'string' && typeof secondArg === 'string') {
+    addTodoUtil(firstArg, secondArg);
+  } else if (Array.isArray(firstArg)) {
+    addTodoCli(firstArg);
+  } else {
+    addTodoCli([firstArg, secondArg].filter((x) => Boolean(x)));
+  }
+}
+function removeTodo(firstArg, secondArg) {
+  if (typeof firstArg === 'string' && typeof secondArg === 'number') {
+    removeTodoUtil(firstArg, secondArg);
+  } else if (Array.isArray(firstArg)) {
+    removeTodoCli(firstArg);
+  } else {
+    removeTodoCli([firstArg]);
+  }
+}
+function listTodos(firstArg) {
+  if (typeof firstArg === 'string' && (firstArg.includes('/') || firstArg.includes('\\'))) {
+    return listTodosUtil(firstArg);
+  } else if (Array.isArray(firstArg)) {
+    listTodosCli(firstArg);
+  } else {
+    listTodosCli(firstArg ? [firstArg] : []);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dashboard,
+  generate,
+  generateClaudeMd,
+  runDashboard,
+  runGenerate,
+  runTelemetry,
+  runTodo,
+  telemetry,
+  todo
+});
+//# sourceMappingURL=index.js.map