@aslomon/effectum 0.3.3 → 0.4.0

package/bin/install.js

@@ -53,6 +53,7 @@ const {
   askLanguage,
   askAutonomy,
   showRecommendation,
+  showCliToolCheck,
   askSetupMode,
   askCustomize,
   askManual,
@@ -61,6 +62,7 @@ const {
   showSummary,
   showOutro,
 } = require("./lib/ui");
+const { checkAllTools, formatToolStatus } = require("./lib/cli-tools");
 
 // ─── File helpers ─────────────────────────────────────────────────────────────
 
@@ -306,6 +308,33 @@ function installBaseFiles(targetDir, repoRoot, isGlobal) {
     steps.push(...copyDir(agentsSrc, agentsDest, { skipExisting: true }));
   }
 
+  // 6. Skills
+  const skillsSrc = path.join(repoRoot, "system", "skills");
+  if (fs.existsSync(skillsSrc)) {
+    const skillsDest = isGlobal
+      ? path.join(targetDir, "skills")
+      : path.join(targetDir, ".claude", "skills");
+    steps.push(...copyDir(skillsSrc, skillsDest, { skipExisting: true }));
+  }
+
+  // 7. Teams (profiles for Agent Teams)
+  const teamsSrc = path.join(repoRoot, "system", "teams");
+  if (fs.existsSync(teamsSrc)) {
+    const teamsDest = isGlobal
+      ? path.join(targetDir, "teams")
+      : path.join(targetDir, ".claude", "teams");
+    steps.push(...copyDir(teamsSrc, teamsDest, { skipExisting: true }));
+  }
+
+  // 8. Hook scripts
+  const hooksSrc = path.join(repoRoot, "system", "hooks");
+  if (fs.existsSync(hooksSrc)) {
+    const hooksDest = isGlobal
+      ? path.join(targetDir, "hooks")
+      : path.join(targetDir, ".claude", "hooks");
+    steps.push(...copyDir(hooksSrc, hooksDest, { skipExisting: true }));
+  }
+
   return steps;
 }
 
@@ -316,7 +345,11 @@ function installRecommendedAgents(targetDir, repoRoot, recommendedAgents) {
   const agentsDest = path.join(targetDir, ".claude", "agents");
   const steps = [];
 
-  if (!fs.existsSync(agentsSrc) || !recommendedAgents || recommendedAgents.length === 0) {
+  if (
+    !fs.existsSync(agentsSrc) ||
+    !recommendedAgents ||
+    recommendedAgents.length === 0
+  ) {
     return steps;
   }
 
@@ -565,6 +598,22 @@ Options:
       process.exit(0);
     }
 
+    // CLI tool check (report only, no install in non-interactive mode)
+    const toolCheck = checkAllTools(config.stack);
+    if (toolCheck.missing.length > 0) {
+      console.log("\n  CLI Tool Check:");
+      console.log(formatToolStatus(toolCheck.tools));
+      console.log(
+        `\n  ${toolCheck.missing.length} tool(s) not installed. Run installer interactively to install.`,
+      );
+    }
+
+    // Store tool status in config
+    config.detectedTools = toolCheck.tools.map((t) => ({
+      key: t.key,
+      installed: t.installed,
+    }));
+
     // Install base files
     installBaseFiles(targetDir, repoRoot, isGlobal);
 
@@ -582,9 +631,13 @@ Options:
     }
 
     // MCP servers — always install recommended MCPs (or explicit --with-mcp)
-    const mcpKeys = config.mcpServers || (config.recommended ? config.recommended.mcps : []) || [];
+    const mcpKeys =
+      config.mcpServers ||
+      (config.recommended ? config.recommended.mcps : []) ||
+      [];
     if (mcpKeys.length > 0 || args.withMcp) {
-      const keysToInstall = mcpKeys.length > 0 ? mcpKeys : MCP_SERVERS.map((s) => s.key);
+      const keysToInstall =
+        mcpKeys.length > 0 ? mcpKeys : MCP_SERVERS.map((s) => s.key);
       const mcpResults = installMcpServers(keysToInstall);
       const settingsPath = isGlobal
         ? path.join(homeClaudeDir, "settings.json")
@@ -673,6 +726,9 @@ Options:
 
   showRecommendation(rec);
 
+  // ── CLI Tool Check ────────────────────────────────────────────────────────
+  const cliToolResult = await showCliToolCheck(stack);
+
   // ── Step 8: Decision ──────────────────────────────────────────────────────
   const setupMode = await askSetupMode();
 
@@ -706,6 +762,10 @@ Options:
     packageManager: detected.packageManager,
     formatter: formatterDef.name,
     mcpServers: finalSetup.mcps,
+    detectedTools: cliToolResult.tools.map((t) => ({
+      key: t.key,
+      installed: t.installed,
+    })),
     playwrightBrowsers: wantPlaywright,
     installScope: "local",
     recommended: {
@@ -777,7 +837,11 @@ Options:
   if (recAgents.length > 0) {
     const sAgents = p.spinner();
     sAgents.start("Installing agent specializations...");
-    const agentSteps = installRecommendedAgents(installTargetDir, repoRoot, recAgents);
+    const agentSteps = installRecommendedAgents(
+      installTargetDir,
+      repoRoot,
+      recAgents,
+    );
     const agentCount = agentSteps.filter((s) => s.status === "created").length;
     sAgents.stop(`${agentCount} agent specializations installed`);
     configSteps.push(...agentSteps);

package/bin/lib/cli-tools.js

@@ -0,0 +1,288 @@
+/**
+ * CLI tool definitions, detection, installation, and auth checking.
+ *
+ * Each tool specifies:
+ *   - key/bin: identifier and binary name
+ *   - install: platform-specific install commands (darwin/linux/all)
+ *   - auth/authSetup: commands to check and configure authentication
+ *   - why: human-readable reason for the tool
+ *   - foundation: true if always recommended regardless of stack
+ *   - stacks: array of stack keys where this tool is relevant
+ */
+"use strict";
+
+const { spawnSync } = require("child_process");
+const os = require("os");
+
+// ─── Tool definitions ────────────────────────────────────────────────────────
+
+const CLI_TOOLS = [
+  // Foundation (always recommended)
+  {
+    key: "git",
+    bin: "git",
+    install: {
+      darwin: "xcode-select --install",
+      linux: "sudo apt install -y git",
+    },
+    auth: "git config user.name && git config user.email",
+    authSetup:
+      'git config --global user.name "Your Name" && git config --global user.email "you@example.com"',
+    why: "Version control — required for all projects",
+    foundation: true,
+  },
+  {
+    key: "gh",
+    bin: "gh",
+    install: { darwin: "brew install gh", linux: "sudo apt install -y gh" },
+    auth: "gh auth status",
+    authSetup: "gh auth login",
+    why: "GitHub: Issues, PRs, Code Search, CI status",
+    foundation: true,
+  },
+  // Stack-specific
+  {
+    key: "supabase",
+    bin: "supabase",
+    install: {
+      darwin: "brew install supabase/tap/supabase",
+      linux: "npm i -g supabase",
+    },
+    auth: "supabase projects list",
+    authSetup: "supabase login",
+    why: "Database migrations, type generation, edge functions",
+    stacks: ["nextjs-supabase"],
+  },
+  {
+    key: "vercel",
+    bin: "vercel",
+    install: { all: "npm i -g vercel" },
+    auth: "vercel whoami",
+    authSetup: "vercel login",
+    why: "Deployment to Vercel",
+    stacks: ["nextjs-supabase"],
+  },
+  {
+    key: "docker",
+    bin: "docker",
+    install: {
+      darwin: "brew install --cask docker",
+      linux: "sudo apt install -y docker.io",
+    },
+    auth: null,
+    why: "Container management, local dev environment",
+    stacks: ["python-fastapi", "generic"],
+  },
+  {
+    key: "uv",
+    bin: "uv",
+    install: { all: "curl -LsSf https://astral.sh/uv/install.sh | sh" },
+    auth: null,
+    why: "Fast Python package management",
+    stacks: ["python-fastapi"],
+  },
+  {
+    key: "ruff",
+    bin: "ruff",
+    install: { all: "pip install ruff" },
+    auth: null,
+    why: "Python linting and formatting",
+    stacks: ["python-fastapi"],
+  },
+  {
+    key: "xcodebuild",
+    bin: "xcodebuild",
+    install: { darwin: "xcode-select --install" },
+    auth: null,
+    why: "iOS/macOS build toolchain",
+    stacks: ["swift-ios"],
+  },
+];
+
+// ─── Tool check ──────────────────────────────────────────────────────────────
+
+/**
+ * Check if a CLI tool is installed by looking up its binary.
+ * @param {string} bin - binary name (e.g. "git", "gh")
+ * @returns {boolean}
+ */
+function checkTool(bin) {
+  try {
+    const result = spawnSync("which", [bin], {
+      timeout: 5000,
+      stdio: "pipe",
+      encoding: "utf8",
+    });
+    return result.status === 0 && result.stdout.trim().length > 0;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Get the relevant tools for a given stack.
+ * Foundation tools are always included.
+ * @param {string} stack - stack key (e.g. "nextjs-supabase")
+ * @returns {Array<object>}
+ */
+function getToolsForStack(stack) {
+  return CLI_TOOLS.filter(
+    (tool) => tool.foundation || (tool.stacks && tool.stacks.includes(stack)),
+  );
+}
+
+/**
+ * Check all relevant tools for a stack and return status.
+ * @param {string} stack
+ * @returns {{ tools: Array<{ key: string, bin: string, installed: boolean, why: string, install: object, auth: string|null, authSetup: string|null }>, missing: Array<object>, installed: Array<object> }}
+ */
+function checkAllTools(stack) {
+  const relevant = getToolsForStack(stack);
+  const results = relevant.map((tool) => ({
+    ...tool,
+    installed: checkTool(tool.bin),
+  }));
+
+  return {
+    tools: results,
+    missing: results.filter((t) => !t.installed),
+    installed: results.filter((t) => t.installed),
+  };
+}
+
+// ─── Tool installation ───────────────────────────────────────────────────────
+
+/**
+ * Get the platform key for install commands.
+ * @returns {"darwin"|"linux"}
+ */
+function getPlatform() {
+  const p = os.platform();
+  return p === "darwin" ? "darwin" : "linux";
+}
+
+/**
+ * Get the install command for a tool on the current platform.
+ * @param {object} tool
+ * @returns {string|null}
+ */
+function getInstallCommand(tool) {
+  if (!tool.install) return null;
+  const platform = getPlatform();
+  return tool.install[platform] || tool.install.all || null;
+}
+
+/**
+ * Install a single tool using its platform-appropriate command.
+ * @param {object} tool
+ * @returns {{ ok: boolean, command: string|null, error?: string }}
+ */
+function installTool(tool) {
+  const command = getInstallCommand(tool);
+  if (!command) {
+    return {
+      ok: false,
+      command: null,
+      error: "No install command for this platform",
+    };
+  }
+
+  try {
+    const result = spawnSync("bash", ["-c", command], {
+      timeout: 120000,
+      stdio: "pipe",
+      encoding: "utf8",
+    });
+    if (result.status === 0) {
+      return { ok: true, command };
+    }
+    return { ok: false, command, error: result.stderr || "Install failed" };
+  } catch (err) {
+    return { ok: false, command, error: err.message };
+  }
+}
+
+// ─── Auth checking ───────────────────────────────────────────────────────────
+
+/**
+ * Check if a tool is authenticated.
+ * @param {object} tool
+ * @returns {{ authenticated: boolean, needsAuth: boolean }}
+ */
+function checkAuth(tool) {
+  if (!tool.auth) {
+    return { authenticated: true, needsAuth: false };
+  }
+
+  try {
+    const result = spawnSync("bash", ["-c", tool.auth], {
+      timeout: 10000,
+      stdio: "pipe",
+      encoding: "utf8",
+    });
+    return {
+      authenticated: result.status === 0,
+      needsAuth: true,
+    };
+  } catch (_) {
+    return { authenticated: false, needsAuth: true };
+  }
+}
+
+// ─── Formatting helpers ──────────────────────────────────────────────────────
+
+/**
+ * Generate a human-readable tools status summary.
+ * @param {Array<object>} tools - tool check results
+ * @returns {string}
+ */
+function formatToolStatus(tools) {
+  return tools
+    .map((t) => {
+      const icon = t.installed ? "\u2705" : "\u274C";
+      return `  ${icon} ${t.key} — ${t.why}`;
+    })
+    .join("\n");
+}
+
+/**
+ * Generate install instructions for missing tools.
+ * @param {Array<object>} missing - missing tools
+ * @returns {string}
+ */
+function formatInstallInstructions(missing) {
+  const platform = getPlatform();
+  return missing
+    .map((t) => {
+      const cmd = t.install[platform] || t.install.all || "N/A";
+      return `  ${t.key}: ${cmd}`;
+    })
+    .join("\n");
+}
+
+/**
+ * Build the AVAILABLE_TOOLS section content for CLAUDE.md.
+ * @param {Array<object>} tools - tool check results
+ * @returns {string}
+ */
+function buildAvailableToolsSection(tools) {
+  const lines = tools.map((t) => {
+    const status = t.installed ? "installed" : "not installed";
+    return `- **${t.key}** (${status}): ${t.why}`;
+  });
+  return lines.join("\n");
+}
+
+module.exports = {
+  CLI_TOOLS,
+  checkTool,
+  getToolsForStack,
+  checkAllTools,
+  getPlatform,
+  getInstallCommand,
+  installTool,
+  checkAuth,
+  formatToolStatus,
+  formatInstallInstructions,
+  buildAvailableToolsSection,
+};

package/bin/lib/specializations.js

@@ -94,6 +94,16 @@ const SUBAGENT_SPECS = [
     label: "Code Reviewer",
     tags: ["testing-heavy", "docs-needed"],
   },
+  {
+    key: "mobile-developer",
+    label: "Mobile Developer",
+    tags: ["native-ui", "frontend-heavy", "swift"],
+  },
+  {
+    key: "data-engineer",
+    label: "Data Engineer",
+    tags: ["data-pipeline", "compute-heavy", "analytics"],
+  },
 ];
 
 /**
@@ -116,7 +126,7 @@ const STACK_SUBAGENTS = {
     "test-automator",
     "api-designer",
   ],
-  "swift-ios": ["ui-designer", "test-automator"],
+  "swift-ios": ["ui-designer", "test-automator", "mobile-developer"],
   generic: ["debugger", "test-automator"],
 };
 

package/bin/lib/template.js

@@ -9,6 +9,7 @@ const fs = require("fs");
 const path = require("path");
 const { FORMATTER_MAP } = require("./constants");
 const { LANGUAGE_INSTRUCTIONS } = require("./languages");
+const { getToolsForStack, checkTool } = require("./cli-tools");
 
 /**
  * Build a substitution map from user config and parsed stack sections.
@@ -23,6 +24,18 @@ function buildSubstitutionMap(config, stackSections) {
     config.customLanguage ||
     LANGUAGE_INSTRUCTIONS.english;
 
+  // Build AVAILABLE_TOOLS section from detected CLI tools
+  const tools = getToolsForStack(config.stack);
+  const toolLines = tools.map((t) => {
+    const installed = checkTool(t.bin);
+    const status = installed ? "installed" : "not installed";
+    return `- **${t.key}** (${status}): ${t.why}`;
+  });
+  const availableTools =
+    toolLines.length > 0
+      ? toolLines.join("\n")
+      : "No CLI tools configured. Run the installer to detect and configure tools.";
+
   return {
     PROJECT_NAME: config.projectName,
     LANGUAGE: langInstruction,
@@ -39,6 +52,7 @@ function buildSubstitutionMap(config, stackSections) {
     PACKAGE_MANAGER: config.packageManager,
     TOOL_SPECIFIC_GUARDRAILS:
       stackSections.TOOL_SPECIFIC_GUARDRAILS || "[Not configured]",
+    AVAILABLE_TOOLS: availableTools,
   };
 }
 

package/bin/lib/ui.js

@@ -19,6 +19,13 @@ const {
   getAllMcps,
   getAllSubagents,
 } = require("./recommendation");
+const {
+  checkAllTools,
+  formatToolStatus,
+  formatInstallInstructions,
+  installTool,
+  checkAuth,
+} = require("./cli-tools");
 
 /** @type {import("@clack/prompts")} */
 let p;
@@ -495,6 +502,106 @@ async function askGitBranch() {
   return { create: true, name };
 }
 
+// ─── CLI Tool Check ─────────────────────────────────────────────────────────
+
+/**
+ * Run CLI tool check and offer installation/auth for missing tools.
+ * @param {string} stack - selected stack key
+ * @returns {Promise<{ tools: Array<object>, missing: Array<object>, installed: Array<object> }>}
+ */
+async function showCliToolCheck(stack) {
+  const result = checkAllTools(stack);
+
+  p.note(formatToolStatus(result.tools), "CLI Tool Check");
+
+  if (result.missing.length === 0) {
+    p.log.success("All CLI tools are installed.");
+  } else {
+    p.log.warn(`${result.missing.length} tool(s) not found.`);
+
+    const action = await p.select({
+      message: "How would you like to handle missing tools?",
+      options: [
+        {
+          value: "install",
+          label: "Install all missing",
+          hint: "Run install commands automatically",
+        },
+        {
+          value: "show",
+          label: "Show commands only",
+          hint: "Display install commands for manual use",
+        },
+        {
+          value: "skip",
+          label: "Skip",
+          hint: "Continue without installing",
+        },
+      ],
+      initialValue: "show",
+    });
+    handleCancel(action);
+
+    if (action === "install") {
+      for (const tool of result.missing) {
+        const s = p.spinner();
+        s.start(`Installing ${tool.key}...`);
+        const installResult = installTool(tool);
+        if (installResult.ok) {
+          tool.installed = true;
+          s.stop(`${tool.key} installed`);
+        } else {
+          s.stop(
+            `${tool.key} failed: ${installResult.error || "unknown error"}`,
+          );
+        }
+      }
+    } else if (action === "show") {
+      p.note(formatInstallInstructions(result.missing), "Install Commands");
+    }
+  }
+
+  // Auth check for installed tools that need auth
+  const authTools = result.tools.filter((t) => t.installed && t.auth);
+
+  if (authTools.length > 0) {
+    const authResults = authTools.map((t) => {
+      const authStatus = checkAuth(t);
+      return { ...t, ...authStatus };
+    });
+
+    const unauthenticated = authResults.filter(
+      (t) => t.needsAuth && !t.authenticated,
+    );
+
+    if (unauthenticated.length > 0) {
+      const authLines = authResults.map((t) => {
+        const icon = t.authenticated ? "\u2705" : "\u274C";
+        return `  ${icon} ${t.key}${!t.authenticated ? ` — run: ${t.authSetup}` : ""}`;
+      });
+      p.note(authLines.join("\n"), "Auth Status");
+
+      const runAuth = await p.confirm({
+        message:
+          "Would you like to run auth commands for unauthenticated tools?",
+        initialValue: false,
+      });
+      handleCancel(runAuth);
+
+      if (runAuth) {
+        p.log.info(
+          "Auth commands require interactive input. Run these manually:\n" +
+            unauthenticated.map((t) => `  ${t.key}: ${t.authSetup}`).join("\n"),
+        );
+      }
+    } else {
+      p.log.success("All tools are authenticated.");
+    }
+  }
+
+  return result;
+}
+
 // ─── Display helpers ────────────────────────────────────────────────────────
 
 /**
@@ -561,6 +668,8 @@ module.exports = {
   askSetupMode,
   askCustomize,
   askManual,
+  // CLI tool check
+  showCliToolCheck,
   // Legacy / utility prompts
   askMcpServers,
   askPlaywright,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aslomon/effectum",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "Autonomous development system for Claude Code \u2014 describe what you want, get production-ready code",
   "bin": {
     "effectum": "bin/effectum.js"