stack-agent 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 stack-agent contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+# stack-agent
+
+AI-powered CLI that helps developers choose and scaffold full-stack applications through conversational interaction.
+
+A senior software architect in your terminal — it walks you through stack decisions, explains trade-offs, and scaffolds your project using official framework tools.
+
+## How it works
+
+1. **Conversation** — The agent asks what you're building, then guides you through frontend, backend, database, auth, payments, AI/LLM, and deployment choices
+2. **Recommendations** — Each stage presents 2-3 options with a recommended pick and trade-off context
+3. **Review** — Once all decisions are made, the agent presents your full stack for approval
+4. **Scaffold** — The agent runs official tools (create-next-app, create-vite, etc.) and generates integration code grounded by current documentation
+
+## Quick start
+
+```bash
+export ANTHROPIC_API_KEY=your-key-here
+npx stack-agent
+```
+
+## Requirements
+
+- Node.js 20+
+- An [Anthropic API key](https://console.anthropic.com/settings/keys)
+
+## What it does
+
+- Delegates base scaffolding to official framework CLIs (create-next-app, create-vite, etc.)
+- Generates integration code (auth, database, payments) using Claude, grounded by up-to-date documentation via MCP
+- Writes `.env.example` with required environment variables
+- Installs dependencies automatically
+
+## Development
+
+```bash
+npm install
+npm run dev          # Run with tsx
+npm test             # Run tests
+npm run build        # Build with tsup
+```
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,765 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import * as p2 from "@clack/prompts";
+
+// src/cli/chat.ts
+import * as p from "@clack/prompts";
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+var marked = new Marked(markedTerminal());
+function renderMarkdown(text2) {
+  return marked.parse(text2).trimEnd();
+}
+function intro2() {
+  p.intro("stack-agent");
+}
+function outro2(message) {
+  p.outro(message);
+}
+function renderError(text2) {
+  p.log.error(text2);
+}
+function renderPlan(plan) {
+  p.log.info(renderMarkdown(plan));
+}
+async function getUserInput(message, placeholder) {
+  const result = await p.text({
+    message: message ?? "\u203A",
+    placeholder: placeholder ?? "Type your message..."
+  });
+  if (p.isCancel(result)) {
+    return null;
+  }
+  return result;
+}
+function createSpinner() {
+  return p.spinner();
+}
+function writeText(text2) {
+  process.stdout.write(text2);
+}
+function writeLine() {
+  process.stdout.write("\n");
+}
+
+// src/agent/loop.ts
+import { join as join2 } from "path";
+
+// src/llm/client.ts
+import Anthropic from "@anthropic-ai/sdk";
+function getClient() {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "ANTHROPIC_API_KEY environment variable is not set. Please set it before running stack-agent."
+    );
+  }
+  return new Anthropic({ apiKey });
+}
+var _client = null;
+function client() {
+  if (!_client) {
+    _client = getClient();
+  }
+  return _client;
+}
+async function chat(options) {
+  const { system, messages, tools, maxTokens, mcpServers } = options;
+  if (mcpServers && Object.keys(mcpServers).length > 0) {
+    const mcpServerList = Object.entries(mcpServers).map(([name, config]) => ({
+      type: "url",
+      name,
+      url: config.url,
+      ...config.apiKey !== void 0 && {
+        authorization_token: config.apiKey
+      }
+    }));
+    return client().beta.messages.create(
+      {
+        model: "claude-sonnet-4-6",
+        max_tokens: maxTokens,
+        system,
+        messages,
+        tools,
+        mcp_servers: mcpServerList
+      },
+      {
+        headers: {
+          "anthropic-beta": "mcp-client-2025-11-20"
+        }
+      }
+    );
+  }
+  return client().messages.create({
+    model: "claude-sonnet-4-6",
+    max_tokens: maxTokens,
+    system,
+    messages,
+    tools
+  });
+}
+async function chatStream(options, callbacks) {
+  const { system, messages, tools, maxTokens } = options;
+  const stream = client().messages.stream({
+    model: "claude-sonnet-4-6",
+    max_tokens: maxTokens,
+    system,
+    messages,
+    tools
+  });
+  stream.on("text", (text2) => {
+    callbacks.onText(text2);
+  });
+  const finalMessage = await stream.finalMessage();
+  for (const block of finalMessage.content) {
+    if (block.type === "tool_use") {
+      callbacks.onToolUse(block);
+    }
+  }
+  callbacks.onComplete({
+    content: finalMessage.content,
+    stop_reason: finalMessage.stop_reason ?? "end_turn"
+  });
+}
+
+// src/agent/progress.ts
+function createProgress() {
+  return {
+    projectName: null,
+    description: null,
+    frontend: null,
+    backend: null,
+    database: null,
+    auth: null,
+    payments: null,
+    ai: null,
+    deployment: null,
+    extras: []
+  };
+}
+function setDecision(progress, category, choice) {
+  if (category === "extras") {
+    return { ...progress, extras: [...progress.extras, choice] };
+  }
+  return { ...progress, [category]: choice };
+}
+function formatChoice(choice) {
+  if (choice === null) return "not yet decided";
+  return choice.component;
+}
+function serializeProgress(progress) {
+  const lines = [
+    `Project Name: ${progress.projectName ?? "not yet decided"}`,
+    `Description: ${progress.description ?? "not yet decided"}`,
+    `Frontend: ${formatChoice(progress.frontend)}`,
+    `Backend: ${formatChoice(progress.backend)}`,
+    `Database: ${formatChoice(progress.database)}`,
+    `Auth: ${formatChoice(progress.auth)}`,
+    `Payments: ${formatChoice(progress.payments)}`,
+    `AI/LLM: ${formatChoice(progress.ai)}`,
+    `Deployment: ${formatChoice(progress.deployment)}`,
+    `Extras: ${progress.extras.length > 0 ? progress.extras.map((e) => e.component).join(", ") : "not yet decided"}`
+  ];
+  return lines.join("\n");
+}
+
+// src/agent/tools.ts
+function conversationToolDefinitions() {
+  return [
+    {
+      name: "set_decision",
+      description: "Commits a stack decision for a given category.",
+      input_schema: {
+        type: "object",
+        properties: {
+          category: {
+            type: "string",
+            enum: ["frontend", "backend", "database", "auth", "payments", "ai", "deployment", "extras"],
+            description: "The stack category being decided."
+          },
+          component: {
+            type: "string",
+            description: "The name of the chosen component or technology."
+          },
+          reasoning: {
+            type: "string",
+            description: "Explanation for why this component was chosen."
+          },
+          scaffoldTool: {
+            type: "string",
+            description: "Optional CLI scaffold tool to use (e.g. create-next-app)."
+          },
+          scaffoldArgs: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional arguments to pass to the scaffold tool."
+          }
+        },
+        required: ["category", "component", "reasoning"]
+      }
+    },
+    {
+      name: "set_project_info",
+      description: "Sets the project name and description.",
+      input_schema: {
+        type: "object",
+        properties: {
+          projectName: {
+            type: "string",
+            description: "The name of the project."
+          },
+          description: {
+            type: "string",
+            description: "A short description of the project."
+          }
+        },
+        required: ["projectName", "description"]
+      }
+    },
+    {
+      name: "summarize_stage",
+      description: "Summarizes the conversation for a completed stage.",
+      input_schema: {
+        type: "object",
+        properties: {
+          category: {
+            type: "string",
+            description: "The stage/category that was just completed."
+          },
+          summary: {
+            type: "string",
+            description: "A concise summary of what was decided in this stage."
+          }
+        },
+        required: ["category", "summary"]
+      }
+    },
+    {
+      name: "present_plan",
+      description: "Signals that all decisions have been made and the plan is ready to present.",
+      input_schema: {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    }
+  ];
+}
+function scaffoldToolDefinitions() {
+  return [
+    {
+      name: "run_scaffold",
+      description: "Runs an official scaffold CLI to bootstrap a project.",
+      input_schema: {
+        type: "object",
+        properties: {
+          tool: {
+            type: "string",
+            description: "The scaffold CLI tool to run (e.g. create-next-app)."
+          },
+          args: {
+            type: "array",
+            items: { type: "string" },
+            description: "Arguments to pass to the scaffold tool."
+          }
+        },
+        required: ["tool", "args"]
+      }
+    },
+    {
+      name: "add_integration",
+      description: "Writes files, installs dependencies, and adds environment variables for an integration.",
+      input_schema: {
+        type: "object",
+        properties: {
+          files: {
+            type: "object",
+            additionalProperties: { type: "string" },
+            description: "Map of file paths to file contents to write."
+          },
+          dependencies: {
+            type: "object",
+            additionalProperties: { type: "string" },
+            description: "Map of package names to versions to install as runtime dependencies."
+          },
+          devDependencies: {
+            type: "object",
+            additionalProperties: { type: "string" },
+            description: "Map of package names to versions to install as dev dependencies."
+          },
+          envVars: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of environment variable names required by the integration."
+          }
+        },
+        required: ["files"]
+      }
+    }
+  ];
+}
+function executeConversationTool(name, input, progress, _messages) {
+  if (name === "set_decision") {
+    const category = input.category;
+    const choice = {
+      component: input.component,
+      reasoning: input.reasoning,
+      ...input.scaffoldTool !== void 0 && { scaffoldTool: input.scaffoldTool },
+      ...input.scaffoldArgs !== void 0 && { scaffoldArgs: input.scaffoldArgs }
+    };
+    const updatedProgress = setDecision(progress, category, choice);
+    return {
+      progress: updatedProgress,
+      response: `Decision recorded: ${choice.component} for ${category}.`
+    };
+  }
+  if (name === "set_project_info") {
+    const updatedProgress = {
+      ...progress,
+      projectName: input.projectName,
+      description: input.description
+    };
+    return {
+      progress: updatedProgress,
+      response: `Project info set: "${input.projectName}".`
+    };
+  }
+  if (name === "summarize_stage") {
+    return {
+      progress,
+      response: input.summary
+    };
+  }
+  if (name === "present_plan") {
+    return {
+      progress,
+      response: "Plan is ready to present.",
+      signal: "present_plan"
+    };
+  }
+  return {
+    progress,
+    response: `Unknown tool: "${name}".`
+  };
+}
+
+// src/agent/system-prompt.ts
+function buildConversationPrompt(progress) {
+  return `You are a senior software architect helping a developer set up a new project.
+
+Your job is to guide the user through selecting their technology stack by having a natural conversation. Work through these categories: frontend, backend, database, auth, payments, ai/llm, deployment, and any extras they might want.
+
+Guidelines:
+- Present 2-3 concrete options per category, plus a "something else" option. Number them (1, 2, 3...) so users can respond quickly.
+- For each set of options, explicitly label your top pick with "(Recommended)" next to it and explain WHY it's the best fit for this specific project. Example: "1. Next.js (Recommended) \u2014 server components, built-in API routes...". Then briefly describe the alternatives and their trade-offs. Be opinionated \u2014 you are a senior architect, not a menu.
+- Keep the conversation focused and friendly. Ask one category at a time.
+- When the user decides on something, call \`set_decision\` to commit that decision before moving on.
+- Start by asking for a project name and a brief description of what they're building. Call \`set_project_info\` to record these before moving to stack decisions.
+- As conversations get long, call \`summarize_stage\` when completing each category to keep context manageable.
+- Once all decisions are made (frontend, database, and deployment are required; backend, auth, payments, and extras are optional), call \`present_plan\` to signal the plan is ready.
+
+Do not ask the user to confirm each tool call \u2014 just make the calls naturally as decisions are reached.
+
+Current project state:
+${serializeProgress(progress)}`;
+}
+function buildScaffoldPrompt(progress) {
+  return `You are scaffolding a new software project based on an approved plan.
+
+Approved plan:
+${serializeProgress(progress)}
+
+Instructions:
+1. Call \`run_scaffold\` first to bootstrap the project using the appropriate scaffold CLI tool (e.g. create-next-app, create-vite, etc.).
+2. After scaffolding, call \`add_integration\` for each integration (database, auth, payments, deployment config, extras) to write necessary files, install dependencies, and declare required environment variables.
+3. Use MCP tools to look up current documentation for any libraries or frameworks you integrate, ensuring you use up-to-date APIs and configuration patterns.
+4. Generate complete, working code \u2014 no stubs, no placeholders, no TODO comments. Every file should be production-ready.
+
+Do not ask for confirmation. Proceed through all steps automatically.`;
+}
+
+// src/scaffold/base.ts
+import { execFileSync } from "child_process";
+import { readdirSync, existsSync } from "fs";
+import { join } from "path";
+var TOOL_ALLOWLIST = /* @__PURE__ */ new Set([
+  "create-next-app",
+  "create-vite",
+  "create-remix",
+  "create-svelte",
+  "create-astro",
+  "nuxi"
+]);
+var TOOL_FLAG_ALLOWLISTS = {
+  "create-next-app": /* @__PURE__ */ new Set([
+    "--typescript",
+    "--js",
+    "--tailwind",
+    "--no-tailwind",
+    "--eslint",
+    "--no-eslint",
+    "--app",
+    "--src-dir",
+    "--no-src-dir",
+    "--import-alias",
+    "--use-npm",
+    "--use-pnpm",
+    "--use-yarn",
+    "--use-bun"
+  ]),
+  "create-vite": /* @__PURE__ */ new Set(["--template"])
+};
+var URL_SCHEME_RE = /https?:|git\+|file:/i;
+var SHELL_META_RE = /[;&|`$(){}[\]<>!#~*?\n\r]/;
+var WHITESPACE_RE = /\s/;
+function validateScaffoldTool(tool, approvedTool) {
+  if (!TOOL_ALLOWLIST.has(tool)) {
+    throw new Error(`Scaffold tool not in allowlist: "${tool}"`);
+  }
+  if (tool !== approvedTool) {
+    throw new Error(`Scaffold tool "${tool}" does not match approved tool "${approvedTool}"`);
+  }
+}
+function validateScaffoldArgs(tool, args) {
+  const strictAllowlist = TOOL_FLAG_ALLOWLISTS[tool];
+  for (const arg of args) {
+    if (URL_SCHEME_RE.test(arg)) {
+      throw new Error(`Scaffold arg contains a URL scheme: "${arg}"`);
+    }
+    if (WHITESPACE_RE.test(arg)) {
+      throw new Error(`Scaffold arg contains whitespace: "${arg}"`);
+    }
+    if (SHELL_META_RE.test(arg)) {
+      throw new Error(`Scaffold arg contains shell metacharacters: "${arg}"`);
+    }
+    if (strictAllowlist !== void 0) {
+      const isFlag = arg.startsWith("--");
+      if (isFlag && !strictAllowlist.has(arg)) {
+        throw new Error(`Scaffold arg "${arg}" is not in the allowlist for tool "${tool}"`);
+      }
+    } else {
+      if (!arg.startsWith("--")) {
+        throw new Error(
+          `Scaffold arg "${arg}" must start with "--" for tool "${tool}"`
+        );
+      }
+    }
+  }
+}
+function runScaffold(tool, args, approvedTool, projectName, cwd) {
+  validateScaffoldTool(tool, approvedTool);
+  validateScaffoldArgs(tool, args);
+  const outputDir = join(cwd, projectName);
+  if (existsSync(outputDir)) {
+    const entries = readdirSync(outputDir);
+    if (entries.length > 0) {
+      throw new Error(
+        `Output directory "${outputDir}" already exists and is not empty`
+      );
+    }
+  }
+  const spawnArgs = [`${tool}@latest`, projectName, ...args];
+  const opts = { cwd, stdio: "pipe" };
+  execFileSync("npx", spawnArgs, opts);
+  return outputDir;
+}
+
+// src/scaffold/integrate.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync as existsSync2, appendFileSync } from "fs";
+import { resolve, relative, dirname, isAbsolute } from "path";
+function validateFilePaths(projectRoot, files) {
+  for (const filePath of Object.keys(files)) {
+    if (isAbsolute(filePath)) {
+      throw new Error(`File path must be relative, got: "${filePath}"`);
+    }
+    const resolved = resolve(projectRoot, filePath);
+    const rel = relative(projectRoot, resolved);
+    if (rel.startsWith("..")) {
+      throw new Error(`File path "${filePath}" resolves outside project root`);
+    }
+  }
+}
+function writeIntegration(projectDir, input) {
+  const { files, dependencies, devDependencies, envVars } = input;
+  validateFilePaths(projectDir, files);
+  for (const [filePath, content] of Object.entries(files)) {
+    const fullPath = resolve(projectDir, filePath);
+    mkdirSync(dirname(fullPath), { recursive: true });
+    writeFileSync(fullPath, content, "utf8");
+  }
+  if (dependencies !== void 0 || devDependencies !== void 0) {
+    const pkgPath = resolve(projectDir, "package.json");
+    let pkg = {};
+    if (existsSync2(pkgPath)) {
+      pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    }
+    if (dependencies !== void 0) {
+      pkg.dependencies = {
+        ...pkg.dependencies,
+        ...dependencies
+      };
+    }
+    if (devDependencies !== void 0) {
+      pkg.devDependencies = {
+        ...pkg.devDependencies,
+        ...devDependencies
+      };
+    }
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  }
+  if (envVars !== void 0 && envVars.length > 0) {
+    const envPath = resolve(projectDir, ".env.example");
+    const lines = envVars.map((v) => `${v}=`).join("\n") + "\n";
+    appendFileSync(envPath, lines, "utf8");
+  }
+}
+
+// src/agent/loop.ts
+async function runConversationLoop(mcpServers) {
+  let progress = createProgress();
+  const messages = [];
+  messages.push({ role: "user", content: "I want to start a new project." });
+  while (true) {
+    const system = buildConversationPrompt(progress);
+    let contentBlocks = [];
+    const collectedToolUse = [];
+    let hasText = false;
+    await chatStream(
+      {
+        system,
+        messages,
+        tools: conversationToolDefinitions(),
+        maxTokens: 4096,
+        mcpServers
+      },
+      {
+        onText: (delta) => {
+          if (!hasText) {
+            hasText = true;
+            writeText("\n");
+          }
+          writeText(delta);
+        },
+        onToolUse: (block) => {
+          collectedToolUse.push(block);
+        },
+        onComplete: (response) => {
+          contentBlocks = response.content;
+        }
+      }
+    );
+    if (hasText) {
+      writeLine();
+      writeLine();
+    }
+    const toolUseBlocks = collectedToolUse;
+    if (toolUseBlocks.length > 0) {
+      messages.push({ role: "assistant", content: contentBlocks });
+      const toolResults = [];
+      let hasPresentPlan = false;
+      let hasSummarizeStage = false;
+      let summarizeSummary = "";
+      for (const block of toolUseBlocks) {
+        const toolBlock = block;
+        const result = executeConversationTool(
+          toolBlock.name,
+          toolBlock.input,
+          progress,
+          messages
+        );
+        progress = result.progress;
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolBlock.id,
+          content: result.response
+        });
+        if (result.signal === "present_plan") {
+          hasPresentPlan = true;
+        }
+        if (toolBlock.name === "summarize_stage") {
+          hasSummarizeStage = true;
+          summarizeSummary = toolBlock.input.summary;
+        }
+      }
+      messages.push({ role: "user", content: toolResults });
+      if (hasSummarizeStage) {
+        const lastAssistant = messages[messages.length - 2];
+        const lastUser = messages[messages.length - 1];
+        messages.length = 0;
+        messages.push({
+          role: "assistant",
+          content: summarizeSummary
+        });
+        messages.push({
+          role: "user",
+          content: "[Continuing]"
+        });
+        messages.push(lastAssistant);
+        messages.push(lastUser);
+      }
+      if (hasPresentPlan) {
+        renderPlan(serializeProgress(progress));
+        return progress;
+      }
+      continue;
+    }
+    const userInput = await getUserInput("Your response");
+    if (userInput === null) return null;
+    messages.push({
+      role: "assistant",
+      content: contentBlocks
+    });
+    messages.push({ role: "user", content: userInput });
+  }
+}
+async function runScaffoldLoop(progress, mcpServers) {
+  const messages = [];
+  const system = buildScaffoldPrompt(progress);
+  const cwd = process.cwd();
+  const projectName = progress.projectName;
+  const projectDir = join2(cwd, projectName);
+  let toolCallCount = 0;
+  const maxToolCalls = 30;
+  messages.push({
+    role: "user",
+    content: "Begin scaffolding the project according to the plan."
+  });
+  while (true) {
+    const response = await chat({
+      system,
+      messages,
+      tools: scaffoldToolDefinitions(),
+      maxTokens: 16384,
+      mcpServers
+    });
+    const contentBlocks = response.content;
+    const toolUseBlocks = contentBlocks.filter(
+      (b) => b.type === "tool_use"
+    );
+    if (toolUseBlocks.length === 0) {
+      return true;
+    }
+    messages.push({ role: "assistant", content: contentBlocks });
+    const toolResults = [];
+    for (const block of toolUseBlocks) {
+      const toolBlock = block;
+      toolCallCount++;
+      if (toolCallCount > maxToolCalls) {
+        renderError(`Tool call limit exceeded (${maxToolCalls}). Stopping scaffold loop.`);
+        return false;
+      }
+      const spinner2 = createSpinner();
+      try {
+        if (toolBlock.name === "run_scaffold") {
+          spinner2.start(`Running scaffold: ${toolBlock.input.tool}`);
+          const approvedTool = findApprovedScaffoldTool(progress);
+          const outputDir = runScaffold(
+            toolBlock.input.tool,
+            toolBlock.input.args,
+            approvedTool,
+            projectName,
+            cwd
+          );
+          spinner2.stop(`Scaffold complete: ${outputDir}`);
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: toolBlock.id,
+            content: `Scaffold completed. Project created at ${outputDir}`
+          });
+        } else if (toolBlock.name === "add_integration") {
+          const integrationDesc = Object.keys(
+            toolBlock.input.files ?? {}
+          ).join(", ");
+          spinner2.start(`Adding integration: ${integrationDesc}`);
+          writeIntegration(projectDir, {
+            files: toolBlock.input.files ?? {},
+            dependencies: toolBlock.input.dependencies,
+            devDependencies: toolBlock.input.devDependencies,
+            envVars: toolBlock.input.envVars
+          });
+          spinner2.stop("Integration added");
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: toolBlock.id,
+            content: "Integration written successfully."
+          });
+        } else {
+          spinner2.stop(`Unknown tool: ${toolBlock.name}`);
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: toolBlock.id,
+            content: `Unknown tool: "${toolBlock.name}".`,
+            is_error: true
+          });
+        }
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        spinner2.stop(`Error: ${errorMessage}`);
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolBlock.id,
+          content: errorMessage,
+          is_error: true
+        });
+      }
+    }
+    messages.push({ role: "user", content: toolResults });
+  }
+}
+function findApprovedScaffoldTool(progress) {
+  const categories = [
+    progress.frontend,
+    progress.backend,
+    progress.database,
+    progress.auth,
+    progress.payments,
+    progress.deployment,
+    ...progress.extras
+  ];
+  for (const choice of categories) {
+    if (choice?.scaffoldTool) {
+      return choice.scaffoldTool;
+    }
+  }
+  return "";
+}
+
+// src/index.ts
+async function main() {
+  intro2();
+  const progress = await runConversationLoop();
+  if (!progress) {
+    outro2("Setup cancelled.");
+    return;
+  }
+  const confirmed = await p2.confirm({
+    message: "Ready to build this stack?"
+  });
+  if (p2.isCancel(confirmed) || !confirmed) {
+    outro2("No problem \u2014 run stack-agent again to start over.");
+    return;
+  }
+  const success = await runScaffoldLoop(progress);
+  if (success) {
+    const nextSteps = [`cd ${progress.projectName}`];
+    nextSteps.push("cp .env.example .env  # fill in your values");
+    nextSteps.push("npm run dev");
+    p2.log.step("Next steps:\n  " + nextSteps.join("\n  "));
+    outro2("Happy building!");
+  } else {
+    renderError("Scaffolding encountered errors. Check the output above.");
+    outro2("You may need to fix issues manually.");
+  }
+}
+var command = process.argv[2];
+if (!command || command === "init") {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+} else {
+  console.error(`Unknown command: ${command}`);
+  console.error("Usage: stack-agent [init]");
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "stack-agent",
+  "version": "0.1.0",
+  "description": "AI-powered CLI that helps developers choose and scaffold full-stack applications through conversational interaction",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alainbrown/stack-agent.git"
+  },
+  "bugs": {
+    "url": "https://github.com/alainbrown/stack-agent/issues"
+  },
+  "homepage": "https://github.com/alainbrown/stack-agent#readme",
+  "keywords": [
+    "cli",
+    "scaffold",
+    "fullstack",
+    "ai",
+    "agent",
+    "developer-tools",
+    "project-setup",
+    "claude",
+    "llm"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "stack-agent": "dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.78.0",
+    "@clack/prompts": "^1.1.0",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/marked-terminal": "^6.1.1",
+    "@types/node": "^25.5.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
+  }
+}