@guuey/create-agentic-app 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Loqu, Inc.
+
+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,31 @@
+# @guuey/create-agentic-app
+
+Scaffold a deployable AI agent for [guuey](https://guuey.com) — agent code,
+MCP servers, and generative UI, in one workspace.
+
+```
+npx @guuey/create-agentic-app my-agent
+cd my-agent
+pnpm install
+pnpm dev            # local: your agent + your MCP servers, hot reload
+guuey login
+guuey deploy        # hosted: agent + MCP servers live on guuey
+```
+
+## What you get
+
+- **A code-mode agent worker** (Claude Agent SDK or OpenAI Agents SDK — pick
+  with `--framework`) built on the open
+  [`@guuey/worker`](https://www.npmjs.com/package/@guuey/worker) protocol.
+  The same worker runs locally and on guuey's hosted runtime, sandboxed and
+  scaled to zero when idle.
+- **A hosted MCP server template** (`mcps/todo`) — your agent's tools, built
+  and hosted by `guuey deploy` alongside the agent.
+- **`guuey.json`** — the single config file describing the agent, its MCP
+  servers, and its ggui generative-UI assets.
+
+## Options
+
+```
+npx @guuey/create-agentic-app <dir> [--framework claude-agent-sdk|openai-agents-sdk] [--skip-install]
+```

package/dist/chunk-JD4RAKEG.js

@@ -0,0 +1,203 @@
+// src/scaffold.ts
+import { promises as fs2 } from "fs";
+import { join, dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/rename.ts
+function renameContent(content, name, scope) {
+  return content.replaceAll("@agentic-app-template/", `@${scope}/`).replaceAll("agentic-app-template", name);
+}
+function isProbablyText(buf) {
+  const window = buf.subarray(0, 8192);
+  return !window.includes(0);
+}
+
+// src/shared.ts
+import { promises as fs } from "fs";
+var NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+function isNpmSafeName(name) {
+  return NAME_PATTERN.test(name);
+}
+function assertNpmSafeName(name, label) {
+  if (!isNpmSafeName(name)) {
+    throw new Error(
+      `Invalid ${label} name "${name}": must be npm-safe (match ${NAME_PATTERN.toString()}).`
+    );
+  }
+}
+function isErrnoException(err) {
+  return err instanceof Error && "code" in err;
+}
+async function pathExists(path) {
+  try {
+    await fs.access(path);
+    return true;
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+async function ensureTargetDir(targetDir, force) {
+  if (!await pathExists(targetDir)) {
+    await fs.mkdir(targetDir, { recursive: true });
+    return;
+  }
+  const entries = await fs.readdir(targetDir);
+  if (entries.length > 0 && !force) {
+    throw new Error(
+      `Target directory "${targetDir}" is not empty. Pass force: true (or --force) to scaffold into it anyway.`
+    );
+  }
+}
+
+// src/scaffold.ts
+var execFileAsync = promisify(execFile);
+var here = dirname(fileURLToPath(import.meta.url));
+var packageRoot = join(here, "..");
+var defaultTemplatesDir = join(packageRoot, "dist", "templates");
+async function listAvailableFrameworks(templatesDir) {
+  try {
+    const entries = await fs2.readdir(templatesDir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+async function resolveTemplateDir(templatesDir, framework) {
+  const dir = join(templatesDir, framework);
+  if (await pathExists(dir)) return dir;
+  const available = await listAvailableFrameworks(templatesDir);
+  const list = available.length > 0 ? available.join(", ") : `(none found under ${templatesDir})`;
+  throw new Error(`No template for framework "${framework}". Available frameworks: ${list}`);
+}
+async function copyTree(src, dest, name, scope) {
+  await fs2.mkdir(dest, { recursive: true });
+  const entries = await fs2.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const destName = renameContent(entry.name, name, scope);
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, destName);
+    if (entry.isDirectory()) {
+      await copyTree(srcPath, destPath, name, scope);
+    } else {
+      const buf = await fs2.readFile(srcPath);
+      if (isProbablyText(buf)) {
+        await fs2.writeFile(destPath, renameContent(buf.toString("utf8"), name, scope), "utf8");
+      } else {
+        await fs2.writeFile(destPath, buf);
+      }
+    }
+  }
+}
+async function seedEnvLocal(projectDir) {
+  const envExample = join(projectDir, ".env.example");
+  const envLocal = join(projectDir, ".env.local");
+  if (!await pathExists(envExample)) return;
+  if (await pathExists(envLocal)) return;
+  await fs2.copyFile(envExample, envLocal);
+}
+async function initGit(projectDir) {
+  try {
+    await execFileAsync("git", ["init"], { cwd: projectDir });
+    await execFileAsync("git", ["add", "-A"], { cwd: projectDir });
+    await execFileAsync(
+      "git",
+      [
+        "-c",
+        "user.name=guuey",
+        "-c",
+        "user.email=scaffold@guuey.com",
+        "commit",
+        "-m",
+        "chore: scaffold"
+      ],
+      { cwd: projectDir }
+    );
+  } catch {
+    console.error(
+      `Warning: git init failed; the project was scaffolded without a repo. Initialize it manually:
+  cd ${projectDir}
+  git init && git add -A && git commit -m "chore: scaffold"`
+    );
+  }
+}
+async function runInstall(projectDir) {
+  try {
+    await execFileAsync("pnpm", ["install"], { cwd: projectDir });
+  } catch {
+    console.error(
+      `Warning: "pnpm install" failed to run automatically. Run it manually:
+  cd ${projectDir}
+  pnpm install`
+    );
+  }
+}
+async function scaffold(opts) {
+  assertNpmSafeName(opts.name, "project");
+  const scope = opts.scope ?? opts.name;
+  const templatesDir = opts.templatesDir ?? defaultTemplatesDir;
+  const templateDir = await resolveTemplateDir(templatesDir, opts.framework);
+  const projectDir = resolve(opts.targetDir);
+  await ensureTargetDir(projectDir, opts.force);
+  await copyTree(templateDir, projectDir, opts.name, scope);
+  await seedEnvLocal(projectDir);
+  if (opts.git !== false) {
+    await initGit(projectDir);
+  }
+  if (opts.install) {
+    await runInstall(projectDir);
+  }
+  return { projectDir };
+}
+
+// src/scaffold-mcp.ts
+import { promises as fs3 } from "fs";
+import { join as join2, dirname as dirname2, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var here2 = dirname2(fileURLToPath2(import.meta.url));
+var packageRoot2 = join2(here2, "..");
+var defaultTemplatesDir2 = join2(packageRoot2, "dist", "templates");
+function renameMcpTokens(content, name, scope) {
+  return renameContent(content.replaceAll("NAME_PLACEHOLDER", name), scope, scope);
+}
+async function copyMcpTree(src, dest, name, scope) {
+  await fs3.mkdir(dest, { recursive: true });
+  const entries = await fs3.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const destName = renameMcpTokens(entry.name, name, scope);
+    const srcPath = join2(src, entry.name);
+    const destPath = join2(dest, destName);
+    if (entry.isDirectory()) {
+      await copyMcpTree(srcPath, destPath, name, scope);
+    } else {
+      const buf = await fs3.readFile(srcPath);
+      if (isProbablyText(buf)) {
+        await fs3.writeFile(destPath, renameMcpTokens(buf.toString("utf8"), name, scope), "utf8");
+      } else {
+        await fs3.writeFile(destPath, buf);
+      }
+    }
+  }
+}
+async function scaffoldMcp(opts) {
+  assertNpmSafeName(opts.name, "MCP");
+  const scope = opts.scope ?? opts.name;
+  const templatesDir = opts.templatesDir ?? defaultTemplatesDir2;
+  const templateDir = join2(templatesDir, "mcp-base");
+  if (!await pathExists(templateDir)) {
+    throw new Error(`No mcp-base template found at ${templateDir}.`);
+  }
+  const mcpDir = resolve2(opts.targetDir);
+  await ensureTargetDir(mcpDir, void 0);
+  await copyMcpTree(templateDir, mcpDir, opts.name, scope);
+  return { mcpDir };
+}
+
+export {
+  isNpmSafeName,
+  scaffold,
+  scaffoldMcp
+};

package/dist/chunk-U7JDNY6B.js

@@ -0,0 +1,149 @@
+// src/scaffold.ts
+import { promises as fs } from "fs";
+import { join, dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/rename.ts
+function renameContent(content, name, scope) {
+  return content.replaceAll("@agentic-app-template/", `@${scope}/`).replaceAll("agentic-app-template", name);
+}
+function isProbablyText(buf) {
+  const window = buf.subarray(0, 8192);
+  return !window.includes(0);
+}
+
+// src/scaffold.ts
+var execFileAsync = promisify(execFile);
+var NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+var here = dirname(fileURLToPath(import.meta.url));
+var packageRoot = join(here, "..");
+var defaultTemplatesDir = join(packageRoot, "dist", "templates");
+function isErrnoException(err) {
+  return err instanceof Error && "code" in err;
+}
+async function pathExists(path) {
+  try {
+    await fs.access(path);
+    return true;
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+async function listAvailableFrameworks(templatesDir) {
+  try {
+    const entries = await fs.readdir(templatesDir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+async function resolveTemplateDir(templatesDir, framework) {
+  const dir = join(templatesDir, framework);
+  if (await pathExists(dir)) return dir;
+  const available = await listAvailableFrameworks(templatesDir);
+  const list = available.length > 0 ? available.join(", ") : `(none found under ${templatesDir})`;
+  throw new Error(`No template for framework "${framework}". Available frameworks: ${list}`);
+}
+async function ensureTargetDir(targetDir, force) {
+  if (!await pathExists(targetDir)) {
+    await fs.mkdir(targetDir, { recursive: true });
+    return;
+  }
+  const entries = await fs.readdir(targetDir);
+  if (entries.length > 0 && !force) {
+    throw new Error(
+      `Target directory "${targetDir}" is not empty. Pass force: true (or --force) to scaffold into it anyway.`
+    );
+  }
+}
+async function copyTree(src, dest, name, scope) {
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const destName = renameContent(entry.name, name, scope);
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, destName);
+    if (entry.isDirectory()) {
+      await copyTree(srcPath, destPath, name, scope);
+    } else {
+      const buf = await fs.readFile(srcPath);
+      if (isProbablyText(buf)) {
+        await fs.writeFile(destPath, renameContent(buf.toString("utf8"), name, scope), "utf8");
+      } else {
+        await fs.writeFile(destPath, buf);
+      }
+    }
+  }
+}
+async function seedEnvLocal(projectDir) {
+  const envExample = join(projectDir, ".env.example");
+  const envLocal = join(projectDir, ".env.local");
+  if (!await pathExists(envExample)) return;
+  if (await pathExists(envLocal)) return;
+  await fs.copyFile(envExample, envLocal);
+}
+async function initGit(projectDir) {
+  try {
+    await execFileAsync("git", ["init"], { cwd: projectDir });
+    await execFileAsync("git", ["add", "-A"], { cwd: projectDir });
+    await execFileAsync(
+      "git",
+      [
+        "-c",
+        "user.name=guuey",
+        "-c",
+        "user.email=scaffold@guuey.com",
+        "commit",
+        "-m",
+        "chore: scaffold"
+      ],
+      { cwd: projectDir }
+    );
+  } catch {
+    console.error(
+      `Warning: git init failed; the project was scaffolded without a repo. Initialize it manually:
+  cd ${projectDir}
+  git init && git add -A && git commit -m "chore: scaffold"`
+    );
+  }
+}
+async function runInstall(projectDir) {
+  try {
+    await execFileAsync("pnpm", ["install"], { cwd: projectDir });
+  } catch {
+    console.error(
+      `Warning: "pnpm install" failed to run automatically. Run it manually:
+  cd ${projectDir}
+  pnpm install`
+    );
+  }
+}
+async function scaffold(opts) {
+  if (!NAME_PATTERN.test(opts.name)) {
+    throw new Error(
+      `Invalid project name "${opts.name}": must be npm-safe (match ${NAME_PATTERN.toString()}).`
+    );
+  }
+  const scope = opts.scope ?? opts.name;
+  const templatesDir = opts.templatesDir ?? defaultTemplatesDir;
+  const templateDir = await resolveTemplateDir(templatesDir, opts.framework);
+  const projectDir = resolve(opts.targetDir);
+  await ensureTargetDir(projectDir, opts.force);
+  await copyTree(templateDir, projectDir, opts.name, scope);
+  await seedEnvLocal(projectDir);
+  if (opts.git !== false) {
+    await initGit(projectDir);
+  }
+  if (opts.install) {
+    await runInstall(projectDir);
+  }
+  return { projectDir };
+}
+
+export {
+  scaffold
+};

package/dist/cli.cjs

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli.ts
+var import_promises = require("readline/promises");
+var import_node_process = require("process");
+
+// src/scaffold.ts
+var import_node_fs2 = require("fs");
+var import_node_path = require("path");
+var import_node_url = require("url");
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+
+// src/rename.ts
+function renameContent(content, name, scope) {
+  return content.replaceAll("@agentic-app-template/", `@${scope}/`).replaceAll("agentic-app-template", name);
+}
+function isProbablyText(buf) {
+  const window = buf.subarray(0, 8192);
+  return !window.includes(0);
+}
+
+// src/shared.ts
+var import_node_fs = require("fs");
+var NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+function isNpmSafeName(name) {
+  return NAME_PATTERN.test(name);
+}
+function assertNpmSafeName(name, label) {
+  if (!isNpmSafeName(name)) {
+    throw new Error(
+      `Invalid ${label} name "${name}": must be npm-safe (match ${NAME_PATTERN.toString()}).`
+    );
+  }
+}
+function isErrnoException(err) {
+  return err instanceof Error && "code" in err;
+}
+async function pathExists(path) {
+  try {
+    await import_node_fs.promises.access(path);
+    return true;
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+async function ensureTargetDir(targetDir, force) {
+  if (!await pathExists(targetDir)) {
+    await import_node_fs.promises.mkdir(targetDir, { recursive: true });
+    return;
+  }
+  const entries = await import_node_fs.promises.readdir(targetDir);
+  if (entries.length > 0 && !force) {
+    throw new Error(
+      `Target directory "${targetDir}" is not empty. Pass force: true (or --force) to scaffold into it anyway.`
+    );
+  }
+}
+
+// src/scaffold.ts
+var import_meta = {};
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var here = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+var packageRoot = (0, import_node_path.join)(here, "..");
+var defaultTemplatesDir = (0, import_node_path.join)(packageRoot, "dist", "templates");
+async function listAvailableFrameworks(templatesDir) {
+  try {
+    const entries = await import_node_fs2.promises.readdir(templatesDir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+async function resolveTemplateDir(templatesDir, framework) {
+  const dir = (0, import_node_path.join)(templatesDir, framework);
+  if (await pathExists(dir)) return dir;
+  const available = await listAvailableFrameworks(templatesDir);
+  const list = available.length > 0 ? available.join(", ") : `(none found under ${templatesDir})`;
+  throw new Error(`No template for framework "${framework}". Available frameworks: ${list}`);
+}
+async function copyTree(src, dest, name, scope) {
+  await import_node_fs2.promises.mkdir(dest, { recursive: true });
+  const entries = await import_node_fs2.promises.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const destName = renameContent(entry.name, name, scope);
+    const srcPath = (0, import_node_path.join)(src, entry.name);
+    const destPath = (0, import_node_path.join)(dest, destName);
+    if (entry.isDirectory()) {
+      await copyTree(srcPath, destPath, name, scope);
+    } else {
+      const buf = await import_node_fs2.promises.readFile(srcPath);
+      if (isProbablyText(buf)) {
+        await import_node_fs2.promises.writeFile(destPath, renameContent(buf.toString("utf8"), name, scope), "utf8");
+      } else {
+        await import_node_fs2.promises.writeFile(destPath, buf);
+      }
+    }
+  }
+}
+async function seedEnvLocal(projectDir) {
+  const envExample = (0, import_node_path.join)(projectDir, ".env.example");
+  const envLocal = (0, import_node_path.join)(projectDir, ".env.local");
+  if (!await pathExists(envExample)) return;
+  if (await pathExists(envLocal)) return;
+  await import_node_fs2.promises.copyFile(envExample, envLocal);
+}
+async function initGit(projectDir) {
+  try {
+    await execFileAsync("git", ["init"], { cwd: projectDir });
+    await execFileAsync("git", ["add", "-A"], { cwd: projectDir });
+    await execFileAsync(
+      "git",
+      [
+        "-c",
+        "user.name=guuey",
+        "-c",
+        "user.email=scaffold@guuey.com",
+        "commit",
+        "-m",
+        "chore: scaffold"
+      ],
+      { cwd: projectDir }
+    );
+  } catch {
+    console.error(
+      `Warning: git init failed; the project was scaffolded without a repo. Initialize it manually:
+  cd ${projectDir}
+  git init && git add -A && git commit -m "chore: scaffold"`
+    );
+  }
+}
+async function runInstall(projectDir) {
+  try {
+    await execFileAsync("pnpm", ["install"], { cwd: projectDir });
+  } catch {
+    console.error(
+      `Warning: "pnpm install" failed to run automatically. Run it manually:
+  cd ${projectDir}
+  pnpm install`
+    );
+  }
+}
+async function scaffold(opts) {
+  assertNpmSafeName(opts.name, "project");
+  const scope = opts.scope ?? opts.name;
+  const templatesDir = opts.templatesDir ?? defaultTemplatesDir;
+  const templateDir = await resolveTemplateDir(templatesDir, opts.framework);
+  const projectDir = (0, import_node_path.resolve)(opts.targetDir);
+  await ensureTargetDir(projectDir, opts.force);
+  await copyTree(templateDir, projectDir, opts.name, scope);
+  await seedEnvLocal(projectDir);
+  if (opts.git !== false) {
+    await initGit(projectDir);
+  }
+  if (opts.install) {
+    await runInstall(projectDir);
+  }
+  return { projectDir };
+}
+
+// src/scaffold-mcp.ts
+var import_node_fs3 = require("fs");
+var import_node_path2 = require("path");
+var import_node_url2 = require("url");
+var import_meta2 = {};
+var here2 = (0, import_node_path2.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
+var packageRoot2 = (0, import_node_path2.join)(here2, "..");
+var defaultTemplatesDir2 = (0, import_node_path2.join)(packageRoot2, "dist", "templates");
+
+// src/cli.ts
+var FRAMEWORKS = ["claude-agent-sdk", "openai-agents-sdk"];
+function isFramework(value) {
+  return FRAMEWORKS.includes(value);
+}
+function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("--")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { positional, flags };
+}
+function printHelp() {
+  console.log(`create-agentic-app -- scaffold a guuey agentic app
+
+Usage: create-agentic-app [target] [options]
+
+Arguments:
+  target               Directory to create the project in (prompted if omitted)
+
+Options:
+  --name <name>         Project name (default: derived from target)
+  --scope <scope>       npm scope for @<scope>/* packages (default: name)
+  --framework <f>       Framework: ${FRAMEWORKS.join(" | ")}
+  --agent <f>           Alias for --framework
+  --install             Run "pnpm install" after scaffolding
+  --no-git              Skip "git init" + initial commit
+  --force               Scaffold into a non-empty target directory
+  --list-agents         List available frameworks and exit
+  --help                Show this help
+
+Examples:
+  create-agentic-app my-app --framework claude-agent-sdk
+  create-agentic-app my-app --agent openai-agents-sdk --install
+`);
+}
+function deriveName(target) {
+  const base = target.split(/[\\/]/).filter(Boolean).pop() ?? target;
+  const slug = base.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+/, "");
+  return slug || "agentic-app";
+}
+async function promptFor(question) {
+  const rl = (0, import_promises.createInterface)({ input: import_node_process.stdin, output: import_node_process.stdout });
+  try {
+    return (await rl.question(question)).trim();
+  } finally {
+    rl.close();
+  }
+}
+async function main() {
+  const { positional, flags } = parseArgs(process.argv.slice(2));
+  if (flags.help) {
+    printHelp();
+    return;
+  }
+  if (flags["list-agents"]) {
+    console.log(FRAMEWORKS.join("\n"));
+    return;
+  }
+  let target = positional[0];
+  if (!target) {
+    target = await promptFor("Project directory: ");
+  }
+  if (!target) {
+    console.error("A target directory is required.");
+    process.exit(1);
+    return;
+  }
+  const frameworkFlag = flags.framework ?? flags.agent;
+  let frameworkInput = typeof frameworkFlag === "string" ? frameworkFlag : void 0;
+  if (!frameworkInput) {
+    frameworkInput = await promptFor(`Framework (${FRAMEWORKS.join(" | ")}): `);
+  }
+  if (!isFramework(frameworkInput)) {
+    console.error(`Unknown framework "${frameworkInput}". Available: ${FRAMEWORKS.join(", ")}`);
+    process.exit(1);
+    return;
+  }
+  const framework = frameworkInput;
+  const name = typeof flags.name === "string" ? flags.name : deriveName(target);
+  const scope = typeof flags.scope === "string" ? flags.scope : void 0;
+  const install = flags.install === true;
+  const { projectDir } = await scaffold({
+    targetDir: target,
+    name,
+    framework,
+    scope,
+    install,
+    git: flags["no-git"] !== true,
+    force: flags.force === true
+  });
+  console.log(`
+Scaffolded "${name}" in ${projectDir}
+`);
+  console.log("Next steps:");
+  console.log(`  cd ${projectDir}`);
+  if (!install) console.log("  pnpm install");
+  console.log("  pnpm dev");
+  console.log("  guuey login && guuey deploy");
+}
+main().catch((err) => {
+  if (err instanceof Error) {
+    console.error(`\u2717 ${err.message}`);
+  } else {
+    console.error(`\u2717 ${err}`);
+  }
+  process.exit(1);
+});

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node