create-creek-app 0.0.0-dev.0 → 0.1.6

package/AGENTS.md

@@ -0,0 +1,136 @@
+# create-creek-app — Agent Reference
+
+You are interacting with `create-creek-app`, a CLI that scaffolds Creek projects from templates. Creek deploys to Cloudflare Workers.
+
+## Capabilities
+
+- Scaffold a new project from a built-in or third-party template
+- Discover available templates and their schemas (JSON output)
+- Validate template parameters before scaffolding
+- Customize templates via JSON data (inline or file)
+
+## Command Reference
+
+All commands output JSON to **stdout**. Progress/errors go to **stderr**.
+
+### Discovery (read-only, no side effects)
+
+```bash
+npx create-creek-app --list
+```
+Returns JSON array to stdout:
+```json
+[
+  { "name": "blank", "description": "Minimal Creek project (no UI)", "capabilities": [] },
+  { "name": "landing", "description": "Landing page with hero and CTA", "capabilities": [] },
+  { "name": "blog", "description": "Blog with posts (D1 database)", "capabilities": ["d1"] }
+]
+```
+
+```bash
+npx create-creek-app --template landing --schema
+```
+Returns the template's JSON Schema to stdout:
+```json
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "title": { "type": "string", "default": "My Product" },
+    "theme": { "type": "string", "enum": ["light", "dark"], "default": "dark" }
+  }
+}
+```
+
+```bash
+npx create-creek-app --template landing --validate --data '{"theme":"dark"}'
+```
+Returns validation result to stdout:
+```json
+{ "valid": true, "errors": [] }
+```
+On failure:
+```json
+{ "valid": false, "errors": [{ "path": "/theme", "message": "must be equal to one of the allowed values" }] }
+```
+
+### Scaffold (creates files)
+
+```bash
+# Non-interactive scaffold
+npx create-creek-app <dir> --template <name> --yes
+
+# With custom parameters
+npx create-creek-app <dir> --template <name> --data '<json>' --yes
+
+# From a JSON config file
+npx create-creek-app <dir> --template <name> --data-file <path> --yes
+
+# Skip install and git init (faster, useful for testing)
+npx create-creek-app <dir> --template <name> --yes --no-install --no-git
+
+# Third-party template from GitHub
+npx create-creek-app <dir> --template github:user/repo --yes
+```
+
+### Deploy (after scaffolding)
+
+```bash
+cd <dir> && npx creek deploy --yes
+```
+
+## Recommended Workflow
+
+1. **`--list`** → pick a template based on description and capabilities
+2. **`--schema`** → read the JSON Schema to know valid parameters
+3. **`--validate`** → check your generated data (optional, scaffold validates too)
+4. **Scaffold** with `--template`, `--data`, `--yes`
+5. **Deploy** with `npx creek deploy --yes`
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| `0` | Success |
+| `1` | Error (validation failure, bad arguments, network error) |
+
+## Available Templates
+
+| Name | Capabilities | Use when |
+|------|-------------|----------|
+| `blank` | — | Agent generates all code from scratch |
+| `landing` | — | Marketing/product landing page |
+| `blog` | D1 | Content site with database |
+| `link-in-bio` | — | Social links page |
+| `api` | D1 | REST API backend |
+| `todo` | D1, Realtime | Full-stack app with WebSocket |
+| `dashboard` | D1, Realtime | Data visualization with live updates |
+| `form` | D1 | Form submissions with database storage |
+| `chatbot` | D1, AI | AI-powered chat with conversation history |
+
+## Template Parameters
+
+Parameters are template-specific. Always run `--schema` to discover them. Common patterns:
+
+- `name` — project name (auto-populated from directory name)
+- `title`, `tagline`, `description` — display text
+- `theme` — typically `"light"` or `"dark"` (enum-constrained)
+- `accentColor` — hex color string
+- `features` — array of `{ title, description }` objects
+
+## What Creek Provides After Deploy
+
+The scaffolded project deploys to Cloudflare's edge network via `creek deploy`. Depending on template capabilities:
+
+- **All templates**: Global CDN, HTTPS, preview URLs
+- **D1**: SQLite database — use `import { db } from "creek"` (no connection strings)
+- **Realtime**: WebSocket — use `import { usePresence } from "creek/react"`
+- **AI**: Workers AI — use `import { ai } from "creek"`
+
+## Important Notes
+
+- Always use `--yes` to skip interactive prompts
+- The `--data` flag accepts inline JSON; use `--data-file` for complex data
+- Templates use runtime config (`creek-data.json`) — users can customize after scaffold by editing this file
+- `creek-template.json` is metadata only — it's removed from the scaffolded project
+- No API keys or credentials needed for scaffolding; `creek deploy` handles auth via OAuth

package/README.md

@@ -0,0 +1,353 @@
+# create-creek-app
+
+[![npm version](https://img.shields.io/npm/v/create-creek-app)](https://www.npmjs.com/package/create-creek-app)
+[![license](https://img.shields.io/npm/l/create-creek-app)](https://github.com/solcreek/creek/blob/main/LICENSE)
+
+Scaffold a new [Creek](https://creek.dev) project from a template — deploy to the edge in two commands.
+
+## What is Creek?
+
+Creek is a deployment platform built on [Cloudflare Workers](https://developers.cloudflare.com/workers/). It replaces the manual setup of `wrangler.toml`, bindings, and resource provisioning with a single `creek.toml` config and zero-config CLI.
+
+- **`creek.toml`** replaces `wrangler.toml` — Creek manages Workers, routes, and bindings for you
+- **`creek deploy`** replaces `wrangler deploy` — one command provisions D1 databases, KV namespaces, R2 buckets, and deploys your code
+- **You own the Cloudflare account** — Creek deploys to your CF account via OAuth, no vendor lock-in
+
+If you already use Wrangler, Creek is a higher-level abstraction. If you're new to Cloudflare, Creek is the fastest way to get started.
+
+## Prerequisites
+
+- **Node.js 18+** (LTS recommended)
+- **Cloudflare account** — free tier works. Not needed for scaffolding, only for `creek deploy` (you'll be prompted to sign in via OAuth on first deploy)
+
+> **`creek` vs `create-creek-app`**: `create-creek-app` scaffolds a new project. `creek` is the CLI that deploys, runs dev server, and manages your project. Both are installed on-demand via `npx`.
+
+## Quick Start
+
+```bash
+# 1. Scaffold a landing page
+npx create-creek-app my-site --template landing --yes
+
+# 2. Local development
+cd my-site && npx creek dev
+# → http://localhost:5173 with hot reload
+
+# 3. Deploy to production
+npx creek deploy
+# → https://my-site-your-team.bycreek.com (live in ~10 seconds)
+```
+
+You get a globally distributed site on Cloudflare's edge network, with optional D1 database, KV storage, R2 files, AI inference, and Realtime WebSockets — all managed by Creek.
+
+## Usage
+
+### Interactive (human)
+
+```bash
+npx create-creek-app
+# prompts: template → project name → scaffold → install → git init
+```
+
+### Non-interactive (agent / CI)
+
+```bash
+npx create-creek-app my-blog --template blog --data '{"name":"Alice"}' --yes
+```
+
+### From a JSON config file
+
+```bash
+npx create-creek-app my-site --template landing --data-file config.json --yes
+```
+
+```json
+// config.json
+{
+  "title": "Acme Corp",
+  "tagline": "The best widgets",
+  "theme": "light",
+  "features": [
+    { "title": "Fast", "description": "Edge-powered performance" },
+    { "title": "Secure", "description": "Built-in DDoS protection" }
+  ]
+}
+```
+
+### Template discovery
+
+```bash
+# List all templates
+npx create-creek-app --list
+```
+
+```json
+[
+  { "name": "blank", "description": "Minimal Creek project (no UI)", "capabilities": [] },
+  { "name": "landing", "description": "Landing page with hero and CTA", "capabilities": [] },
+  { "name": "blog", "description": "Blog with posts (D1 database)", "capabilities": ["d1"] },
+  ...
+]
+```
+
+```bash
+# Print a template's JSON Schema
+npx create-creek-app --template landing --schema
+```
+
+```json
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "title": { "type": "string", "default": "My Product" },
+    "theme": { "type": "string", "enum": ["light", "dark"], "default": "dark" }
+  }
+}
+```
+
+```bash
+# Validate data before scaffolding
+npx create-creek-app --template landing --validate --data '{"theme":"dark"}'
+# → { "valid": true, "errors": [] }
+```
+
+### Third-party templates
+
+```bash
+npx create-creek-app --template github:user/my-template
+```
+
+## Options
+
+```
+npx create-creek-app [dir] [options]
+
+  dir                                     Project directory (default: prompted or "my-creek-app")
+
+  -t, --template <name|github:user/repo>  Template to use
+  --data <json>                           JSON data for template params
+  --data-file <path>                      JSON file for template params
+  --list                                  List available templates (JSON)
+  --schema                                Print template JSON Schema
+  --validate                              Validate data against schema
+  --registry <url>                        Private template registry (enterprise)
+  -y, --yes                               Skip prompts, use defaults
+  --no-install                            Skip dependency installation
+  --no-git                                Skip git init
+```
+
+## Templates
+
+Each template is a complete, deployable project — not a skeleton. Capabilities indicate which Creek-managed resources are pre-configured:
+
+| Template | Description | Capabilities |
+|----------|-------------|-------------|
+| `blank` | Minimal Creek project (no UI) | — |
+| `landing` | Landing page with hero and CTA | — |
+| `blog` | Blog with posts | D1 database |
+| `link-in-bio` | Social links page | — |
+| `api` | REST API with Hono | D1 database |
+| `todo` | Realtime todo app | D1 + WebSocket |
+| `dashboard` | Data dashboard | D1 + WebSocket |
+| `form` | Form collector | D1 database |
+| `chatbot` | AI chatbot | D1 + Workers AI |
+
+**Capabilities explained:**
+- **D1** — SQLite database at the edge, managed by Creek (no connection strings, no migrations)
+- **Realtime** — WebSocket connections via Creek's Realtime service (presence, broadcast)
+- **AI** — Inference via Cloudflare Workers AI (LLMs, embeddings, image generation)
+
+## Template Schema
+
+Each template defines customizable parameters via [JSON Schema](https://json-schema.org/) in `creek-template.json`. This enables both human prompts and programmatic validation.
+
+### creek-template.json
+
+```json
+{
+  "name": "landing",
+  "description": "Landing page with hero, features, and CTA",
+  "capabilities": [],
+  "schema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "title": { "type": "string", "default": "My Product" },
+      "tagline": { "type": "string", "default": "Ship faster with Creek" },
+      "theme": {
+        "type": "string",
+        "enum": ["light", "dark"],
+        "default": "dark"
+      }
+    }
+  }
+}
+```
+
+### Fields
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `name` | string | yes | Template identifier |
+| `description` | string | yes | Short description |
+| `capabilities` | string[] | yes | Creek resources used: `d1`, `kv`, `r2`, `ai`, `realtime` |
+| `thumbnail` | string | no | Path or URL to thumbnail image (400x300 recommended) |
+| `screenshot` | string | no | Path or URL to full screenshot image |
+| `schema` | object | no | JSON Schema defining customizable parameters |
+
+### creek-data.json
+
+Default values for the schema parameters. Your app reads this file at runtime — no build-time string replacement. Users customize their project by editing this one file.
+
+```json
+{
+  "title": "My Product",
+  "tagline": "Ship faster with Creek",
+  "theme": "dark"
+}
+```
+
+```tsx
+// src/App.tsx — reads config at runtime
+import data from "../creek-data.json";
+
+export function App() {
+  return <h1>{data.title}</h1>;
+}
+```
+
+## Validation
+
+Data is validated against the template's JSON Schema using [ajv](https://ajv.js.org/). Validation runs automatically during scaffold and can be triggered independently with `--validate`.
+
+### Supported constraints
+
+- **type** — `string`, `number`, `integer`, `boolean`, `array`, `object`
+- **enum** — fixed set of allowed values
+- **default** — applied when the property is omitted
+- **required** — within object items (array entries, nested objects)
+- **items** — schema for array elements
+- **nested objects** — full recursive validation
+
+### Validation examples
+
+```bash
+# Valid — passes (exit code 0)
+npx create-creek-app --template landing --validate --data '{"theme":"dark"}'
+# → { "valid": true, "errors": [] }
+
+# Invalid enum — fails (exit code 1)
+npx create-creek-app --template landing --validate --data '{"theme":"invalid"}'
+# → { "valid": false, "errors": [{ "path": "/theme", "message": "must be equal to one of the allowed values" }] }
+```
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| `0` | Success |
+| `1` | Error — validation failure, invalid arguments, scaffold failure, or network error |
+
+All structured output (`--list`, `--schema`, `--validate`) goes to **stdout** as JSON. Progress messages and errors go to **stderr**.
+
+## Creating Custom Templates
+
+A Creek template is a directory with at minimum a `package.json` and `creek.toml`. Add `creek-template.json` for schema-driven customization.
+
+### Template structure
+
+```
+my-template/
+├── creek-template.json       ← schema + metadata (removed on scaffold)
+├── creek-data.json           ← default values (optional)
+├── creek.toml                ← Creek project config
+├── package.json
+├── src/                      ← your code
+├── worker/index.ts           ← edge worker (if needed)
+└── .gitignore
+```
+
+### Best practices
+
+1. **Use JSON Schema defaults** — every property should have a `default` so the template works without any `--data`
+2. **Read config at runtime** — import `creek-data.json` in your code instead of build-time placeholders
+3. **Keep schemas flat** — prefer top-level string/number/boolean properties
+4. **Use `enum` for constrained choices** — themes, layouts, color schemes. Agents discover valid options via `--schema`
+5. **Include a `name` property** — `create-creek-app` auto-populates it from the project directory
+
+### Publishing
+
+Host your template on GitHub and use it directly:
+
+```bash
+npx create-creek-app --template github:yourname/my-template
+```
+
+Or submit it to the [Creek template gallery](https://github.com/solcreek/templates) via pull request.
+
+## Agent Workflow
+
+`create-creek-app` is designed for both humans and AI agents. Typical agent flow:
+
+```bash
+# 1. Discover templates
+npx create-creek-app --list
+# → JSON array to stdout
+
+# 2. Read schema for chosen template
+npx create-creek-app --template landing --schema
+# → JSON Schema to stdout
+
+# 3. Validate generated data
+npx create-creek-app --template landing --validate --data '{"title":"Acme","theme":"dark"}'
+# → { "valid": true, "errors": [] }
+
+# 4. Scaffold
+npx create-creek-app my-site --template landing --data '{"title":"Acme"}' --yes
+
+# 5. Deploy
+cd my-site && npx creek deploy --yes
+# → { "ok": true, "url": "https://my-site-team.bycreek.com", ... }
+```
+
+All discovery and validation commands output JSON to stdout for programmatic consumption. Use `--yes` to skip all interactive prompts.
+
+## Contributing Templates
+
+The template ecosystem is open to everyone. We welcome contributions from individual developers, agencies, and framework authors.
+
+### How to submit
+
+1. Fork [solcreek/templates](https://github.com/solcreek/templates)
+2. Create your template directory following the [template structure](#template-structure)
+3. Ensure it scaffolds and deploys cleanly: `npx create-creek-app test-dir --template ./your-template --yes && cd test-dir && creek deploy`
+4. Open a pull request
+
+### Acceptance criteria
+
+- **Works out of the box** — `--yes` with no `--data` must produce a deployable project
+- **Has `creek-template.json`** — with description, capabilities, and schema (if customizable)
+- **No secrets or API keys** — templates must not require external service credentials to scaffold
+- **English** — template names, descriptions, and code comments in English
+
+### Template tiers
+
+| Tier | Badge | Maintained by | Review |
+|------|-------|--------------|--------|
+| **Official** | `solcreek/templates` | Creek team | Creek team review |
+| **Community** | `github:author/repo` | Author | Self-published, no review required |
+
+Official templates are held to a higher standard: they must stay compatible with the latest Creek CLI and are tested in CI. Community templates can be used by anyone via `--template github:author/repo` — no approval process needed.
+
+### Ideas for templates
+
+We'd especially love to see:
+- Framework-specific starters (Astro + Creek, SvelteKit + Creek)
+- Industry verticals (restaurant menu, event page, portfolio)
+- Backend patterns (webhook receiver, cron job, queue processor)
+
+See the [templates repo](https://github.com/solcreek/templates) for the full contribution guide.
+
+## License
+
+Apache-2.0

package/dist/apply-data.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Merge user-supplied data into creek-data.json (and update creek.toml project name).
+ * `defaults` is what was already in the template's creek-data.json.
+ */
+export declare function applyData(dir: string, userData: Record<string, unknown>, defaults: Record<string, unknown>): void;

package/dist/apply-data.js

@@ -0,0 +1,33 @@
+import { join } from "node:path";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+/**
+ * Merge user-supplied data into creek-data.json (and update creek.toml project name).
+ * `defaults` is what was already in the template's creek-data.json.
+ */
+export function applyData(dir, userData, defaults) {
+    const merged = { ...defaults, ...userData };
+    // Write merged creek-data.json
+    const dataPath = join(dir, "creek-data.json");
+    writeFileSync(dataPath, JSON.stringify(merged, null, 2) + "\n");
+    // If "name" was provided, also update creek.toml and package.json
+    if (typeof merged.name === "string") {
+        updateCreekTomlName(dir, merged.name);
+        updatePackageJsonName(dir, merged.name);
+    }
+}
+function updateCreekTomlName(dir, name) {
+    const tomlPath = join(dir, "creek.toml");
+    if (!existsSync(tomlPath))
+        return;
+    let content = readFileSync(tomlPath, "utf-8");
+    content = content.replace(/^name\s*=\s*"[^"]*"/m, `name = "${name}"`);
+    writeFileSync(tomlPath, content);
+}
+function updatePackageJsonName(dir, name) {
+    const pkgPath = join(dir, "package.json");
+    if (!existsSync(pkgPath))
+        return;
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    pkg.name = name;
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}

package/dist/fetch.d.ts

@@ -0,0 +1,20 @@
+export interface FetchResult {
+    dir: string;
+    templateConfig: TemplateConfig | null;
+    defaultData: Record<string, unknown>;
+}
+export interface TemplateConfig {
+    name: string;
+    description: string;
+    capabilities: string[];
+    thumbnail?: string;
+    screenshot?: string;
+    schema?: Record<string, unknown>;
+}
+/**
+ * Download a template into `dest`.
+ *
+ * Built-in templates:  "landing"  → github:solcreek/templates/landing
+ * Third-party:         "github:user/repo" → passed to giget directly
+ */
+export declare function fetchTemplate(template: string, dest: string): Promise<FetchResult>;

package/dist/fetch.js

@@ -0,0 +1,35 @@
+import { downloadTemplate } from "giget";
+import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+const TEMPLATE_REPO = "github:solcreek/templates";
+/**
+ * Download a template into `dest`.
+ *
+ * Built-in templates:  "landing"  → github:solcreek/templates/landing
+ * Third-party:         "github:user/repo" → passed to giget directly
+ */
+export async function fetchTemplate(template, dest) {
+    const source = isThirdParty(template)
+        ? template
+        : `${TEMPLATE_REPO}/${template}`;
+    const { dir } = await downloadTemplate(source, {
+        dir: dest,
+        force: true,
+    });
+    // Read creek-template.json if present
+    const configPath = join(dir, "creek-template.json");
+    let templateConfig = null;
+    if (existsSync(configPath)) {
+        templateConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+    // Read creek-data.json defaults if present
+    const dataPath = join(dir, "creek-data.json");
+    let defaultData = {};
+    if (existsSync(dataPath)) {
+        defaultData = JSON.parse(readFileSync(dataPath, "utf-8"));
+    }
+    return { dir, templateConfig, defaultData };
+}
+function isThirdParty(template) {
+    return (template.includes(":") || template.includes("/") || template.startsWith("."));
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+import consola from "consola";
+import { mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { TEMPLATES } from "./templates.js";
+import { scaffold } from "./scaffold.js";
+import { validateData } from "./validate.js";
+import { fetchTemplate } from "./fetch.js";
+import { promptTemplate, promptDir } from "./prompts.js";
+const main = defineCommand({
+    meta: {
+        name: "create-creek-app",
+        description: "Create a new Creek project from a template",
+    },
+    args: {
+        dir: {
+            type: "positional",
+            description: "Project directory",
+            required: false,
+        },
+        template: {
+            type: "string",
+            alias: "t",
+            description: "Template name or github:user/repo",
+        },
+        data: {
+            type: "string",
+            description: "JSON data for template params",
+        },
+        "data-file": {
+            type: "string",
+            description: "Path to JSON file for template params",
+        },
+        list: {
+            type: "boolean",
+            description: "List available templates (JSON)",
+            default: false,
+        },
+        schema: {
+            type: "boolean",
+            description: "Print template JSON Schema",
+            default: false,
+        },
+        validate: {
+            type: "boolean",
+            description: "Validate data against template schema",
+            default: false,
+        },
+        registry: {
+            type: "string",
+            description: "Private template registry URL (enterprise)",
+        },
+        yes: {
+            type: "boolean",
+            alias: "y",
+            description: "Skip prompts, use defaults",
+            default: false,
+        },
+        install: {
+            type: "boolean",
+            description: "Install dependencies (use --no-install to skip)",
+            default: true,
+        },
+        git: {
+            type: "boolean",
+            description: "Initialize git repo (use --no-git to skip)",
+            default: true,
+        },
+    },
+    async run({ args }) {
+        // --registry: enterprise placeholder
+        if (args.registry) {
+            console.log(JSON.stringify({
+                error: "Private template registry is an enterprise feature. Coming soon — creek.dev/enterprise",
+            }));
+            process.exit(0);
+        }
+        // --list: output JSON array of templates
+        if (args.list) {
+            console.log(JSON.stringify(TEMPLATES, null, 2));
+            return;
+        }
+        // --schema: print template's JSON Schema
+        if (args.schema) {
+            const templateName = args.template;
+            if (!templateName) {
+                consola.error("--schema requires --template <name>");
+                process.exit(1);
+            }
+            const { templateConfig } = await fetchTemplate(templateName, makeTempDir());
+            if (!templateConfig?.schema) {
+                consola.error(`Template "${templateName}" has no schema`);
+                process.exit(1);
+            }
+            console.log(JSON.stringify(templateConfig.schema, null, 2));
+            return;
+        }
+        // Parse user data from --data or --data-file
+        let userData = {};
+        if (args.data) {
+            try {
+                userData = JSON.parse(args.data);
+            }
+            catch {
+                consola.error("Invalid JSON in --data");
+                process.exit(1);
+            }
+        }
+        else if (args["data-file"]) {
+            try {
+                userData = JSON.parse(readFileSync(args["data-file"], "utf-8"));
+            }
+            catch {
+                consola.error(`Cannot read --data-file: ${args["data-file"]}`);
+                process.exit(1);
+            }
+        }
+        // --validate: validate data and exit
+        if (args.validate) {
+            const templateName = args.template;
+            if (!templateName) {
+                consola.error("--validate requires --template <name>");
+                process.exit(1);
+            }
+            const { templateConfig, defaultData } = await fetchTemplate(templateName, makeTempDir());
+            if (!templateConfig?.schema) {
+                console.log(JSON.stringify({ valid: true, errors: [] }));
+                return;
+            }
+            const merged = { ...defaultData, ...userData };
+            const result = validateData(templateConfig.schema, merged);
+            console.log(JSON.stringify(result, null, 2));
+            process.exit(result.valid ? 0 : 1);
+        }
+        // Interactive or direct scaffold
+        let template = args.template;
+        let dir = args.dir;
+        if (!args.yes) {
+            // Interactive mode
+            if (!template) {
+                template = await promptTemplate();
+            }
+            if (!dir) {
+                dir = await promptDir();
+            }
+        }
+        else {
+            // Non-interactive: require --template, default dir
+            if (!template) {
+                template = "blank";
+            }
+            if (!dir) {
+                dir = "my-creek-app";
+            }
+        }
+        await scaffold({
+            template,
+            dir,
+            data: userData,
+            install: args.install,
+            git: args.git,
+            silent: false,
+        });
+    },
+});
+function makeTempDir() {
+    return mkdtempSync(join(tmpdir(), "creek-tpl-"));
+}
+runMain(main);

package/dist/prompts.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Interactive template picker — used when no --template flag is given.
+ */
+export declare function promptTemplate(): Promise<string>;
+/**
+ * Prompt for project directory name.
+ */
+export declare function promptDir(): Promise<string>;

package/dist/prompts.js

@@ -0,0 +1,29 @@
+import consola from "consola";
+import { TEMPLATES } from "./templates.js";
+/**
+ * Interactive template picker — used when no --template flag is given.
+ */
+export async function promptTemplate() {
+    const choices = TEMPLATES.map((t) => ({
+        label: `${t.name} — ${t.description}`,
+        value: t.name,
+        hint: t.capabilities.length ? t.capabilities.join(", ") : undefined,
+    }));
+    const selected = await consola.prompt("Select a template:", {
+        type: "select",
+        options: choices,
+    });
+    // consola.prompt returns the value string for select type
+    return selected;
+}
+/**
+ * Prompt for project directory name.
+ */
+export async function promptDir() {
+    const dir = await consola.prompt("Project name:", {
+        type: "text",
+        default: "my-creek-app",
+        placeholder: "my-creek-app",
+    });
+    return dir;
+}

package/dist/scaffold.d.ts

@@ -0,0 +1,14 @@
+export interface ScaffoldOptions {
+    template: string;
+    dir: string;
+    data?: Record<string, unknown>;
+    install?: boolean;
+    git?: boolean;
+    silent?: boolean;
+}
+export interface ScaffoldResult {
+    dir: string;
+    template: string;
+    name: string;
+}
+export declare function scaffold(opts: ScaffoldOptions): Promise<ScaffoldResult>;

package/dist/scaffold.js

@@ -0,0 +1,76 @@
+import { resolve, basename } from "node:path";
+import { existsSync, unlinkSync } from "node:fs";
+import { execSync } from "node:child_process";
+import consola from "consola";
+import { fetchTemplate } from "./fetch.js";
+import { applyData } from "./apply-data.js";
+import { validateData } from "./validate.js";
+export async function scaffold(opts) {
+    const dest = resolve(opts.dir);
+    const projectName = basename(dest);
+    // 1. Fetch template
+    if (!opts.silent)
+        consola.start(`Downloading template: ${opts.template}`);
+    const { dir, templateConfig, defaultData } = await fetchTemplate(opts.template, dest);
+    // 2. Validate user data against schema (if schema exists)
+    const userData = { name: projectName, ...(opts.data ?? {}) };
+    if (templateConfig?.schema) {
+        const result = validateData(templateConfig.schema, { ...defaultData, ...userData });
+        if (!result.valid) {
+            consola.error("Data validation failed:");
+            for (const err of result.errors) {
+                consola.error(`  ${err.path}: ${err.message}`);
+            }
+            throw new Error("Template data validation failed");
+        }
+    }
+    // 3. Apply data
+    applyData(dir, userData, defaultData);
+    // 4. Remove creek-template.json from output (metadata, not project file)
+    const templateConfigPath = resolve(dir, "creek-template.json");
+    if (existsSync(templateConfigPath)) {
+        unlinkSync(templateConfigPath);
+    }
+    // 6. Install dependencies
+    if (opts.install !== false) {
+        const pkgPath = resolve(dir, "package.json");
+        if (existsSync(pkgPath)) {
+            if (!opts.silent)
+                consola.start("Installing dependencies...");
+            try {
+                execSync("npm install", { cwd: dir, stdio: "pipe" });
+                if (!opts.silent)
+                    consola.success("Dependencies installed");
+            }
+            catch {
+                consola.warn("Failed to install dependencies. Run `npm install` manually.");
+            }
+        }
+    }
+    // 7. Git init
+    if (opts.git !== false) {
+        try {
+            execSync("git init", { cwd: dir, stdio: "pipe" });
+            execSync("git add -A", { cwd: dir, stdio: "pipe" });
+            execSync('git commit -m "Initial commit from create-creek-app"', {
+                cwd: dir,
+                stdio: "pipe",
+            });
+            if (!opts.silent)
+                consola.success("Git repository initialized");
+        }
+        catch {
+            // git not available or failed — that's fine
+        }
+    }
+    if (!opts.silent) {
+        console.log("");
+        consola.success(`Created ${projectName} with template "${opts.template}"`);
+        console.log("");
+        consola.info("  Next steps:");
+        consola.info(`    cd ${projectName}`);
+        consola.info("    creek deploy    Deploy to production");
+        consola.info("    creek dev       Start local development");
+    }
+    return { dir, template: opts.template, name: projectName };
+}

package/dist/templates.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Template catalog — used for --list, interactive prompt, and gallery.
+ *
+ * Four types by output:
+ *   site      — Visual pages (deploy → shareable URL)
+ *   app       — Interactive UI + backend logic
+ *   workflow  — Background process (no/minimal UI), trigger + steps
+ *   connector — Data bridge pattern (ingestion → storage)
+ */
+export interface Template {
+    name: string;
+    description: string;
+    type: "site" | "app" | "workflow" | "connector" | "developer";
+    capabilities: string[];
+    trigger?: string;
+}
+export declare const TEMPLATES: Template[];
+export type TemplateName = (typeof TEMPLATES)[number]["name"];
+export type TemplateType = Template["type"];

package/dist/templates.js

@@ -0,0 +1,38 @@
+/**
+ * Template catalog — used for --list, interactive prompt, and gallery.
+ *
+ * Four types by output:
+ *   site      — Visual pages (deploy → shareable URL)
+ *   app       — Interactive UI + backend logic
+ *   workflow  — Background process (no/minimal UI), trigger + steps
+ *   connector — Data bridge pattern (ingestion → storage)
+ */
+export const TEMPLATES = [
+    // --- Sites (Level 4 — deploy → shareable) ---
+    { name: "landing", description: "Landing page with hero and CTA", type: "site", capabilities: [] },
+    { name: "blog", description: "Blog with image uploads", type: "site", capabilities: ["database", "storage"] },
+    { name: "link-in-bio", description: "Social links page", type: "site", capabilities: [] },
+    { name: "waitlist", description: "Waitlist with AI user segmentation", type: "site", capabilities: ["database", "ai"] },
+    // --- Apps (Level 3 — working data pipeline + UI) ---
+    { name: "form", description: "Form collector with admin dashboard", type: "app", capabilities: ["database"] },
+    { name: "dashboard", description: "Data dashboard with scheduled refresh", type: "app", capabilities: ["database", "realtime", "cron"] },
+    { name: "chatbot", description: "AI chatbot with conversation history", type: "app", capabilities: ["database", "ai"] },
+    { name: "survey", description: "Survey with AI-powered analysis", type: "app", capabilities: ["database", "ai"] },
+    { name: "knowledge-base", description: "Knowledge base with AI search", type: "app", capabilities: ["database", "ai", "storage"] },
+    { name: "status-page", description: "Service status page with uptime monitoring", type: "app", capabilities: ["database", "realtime", "cron", "cache"] },
+    { name: "file-share", description: "File upload/download with expiring links", type: "app", capabilities: ["database", "storage"] },
+    { name: "todo", description: "Realtime todo app (learning example)", type: "app", capabilities: ["database", "realtime"] },
+    // --- Workflows (Level 2-3 — trigger + steps, no/minimal UI) ---
+    { name: "approval-flow", description: "Approval workflow — leave, expense, procurement", type: "workflow", capabilities: ["database", "realtime", "queue"], trigger: "webhook" },
+    { name: "invoice-processor", description: "Email invoice → AI extract → DB → notify", type: "workflow", capabilities: ["database", "ai", "storage", "email"], trigger: "email" },
+    { name: "scheduled-report", description: "Scheduled query → AI summary → PDF report", type: "workflow", capabilities: ["database", "ai", "storage", "cron"], trigger: "cron" },
+    { name: "data-sync", description: "Scheduled API pull → diff → DB → notify", type: "workflow", capabilities: ["database", "cron"], trigger: "cron" },
+    { name: "ai-classifier", description: "Input → AI classify → route to queue", type: "workflow", capabilities: ["database", "ai", "queue"], trigger: "webhook" },
+    // --- Connectors (Level 2 — pure platform wiring) ---
+    { name: "api", description: "REST API with Hono", type: "connector", capabilities: ["database"], trigger: "http" },
+    { name: "webhook-receiver", description: "Receive and process external webhooks", type: "connector", capabilities: ["database", "queue"], trigger: "webhook" },
+    { name: "email-to-db", description: "Email → parse → attachments to R2 → DB", type: "connector", capabilities: ["database", "storage", "email"], trigger: "email" },
+    { name: "ftp-sync", description: "Scheduled FTP/SFTP pull → parse → DB", type: "connector", capabilities: ["database", "storage", "cron", "ftp"], trigger: "cron" },
+    // --- Developer ---
+    { name: "blank", description: "Minimal Creek project (empty canvas)", type: "developer", capabilities: [] },
+];

package/dist/validate.d.ts

@@ -0,0 +1,13 @@
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+export interface ValidationError {
+    path: string;
+    message: string;
+}
+/**
+ * Validate data against a JSON Schema from creek-template.json.
+ * Returns { valid, errors }.
+ */
+export declare function validateData(schema: Record<string, unknown>, data: Record<string, unknown>): ValidationResult;

package/dist/validate.js

@@ -0,0 +1,20 @@
+import Ajv from "ajv";
+const ajv = new Ajv({ allErrors: true, useDefaults: true });
+/**
+ * Validate data against a JSON Schema from creek-template.json.
+ * Returns { valid, errors }.
+ */
+export function validateData(schema, data) {
+    // Strip $schema meta field — ajv doesn't support 2020-12 meta-schema by default
+    const { $schema: _, ...schemaWithoutMeta } = schema;
+    const validate = ajv.compile(schemaWithoutMeta);
+    const valid = validate(data);
+    if (valid) {
+        return { valid: true, errors: [] };
+    }
+    const errors = (validate.errors ?? []).map((err) => ({
+        path: err.instancePath || "/",
+        message: err.message ?? "unknown error",
+    }));
+    return { valid: false, errors };
+}

package/package.json

@@ -1,8 +1,47 @@
 {
   "name": "create-creek-app",
-  "version": "0.0.0-dev.0",
+  "version": "0.1.6",
+  "description": "Create a new Creek project from a template",
   "type": "module",
   "bin": {
-    "create-creek-app": "./bin/create-creek-app.js"
+    "create-creek-app": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "AGENTS.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "creek",
+    "create",
+    "scaffold",
+    "template",
+    "cloudflare",
+    "workers",
+    "d1"
+  ],
+  "author": "SolCreek",
+  "license": "Apache-2.0",
+  "homepage": "https://creek.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/solcreek/creek.git",
+    "directory": "packages/create-creek-app"
+  },
+  "dependencies": {
+    "citty": "^0.1.6",
+    "consola": "^3.4.2",
+    "giget": "^2.0.0",
+    "ajv": "^8.17.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.2",
+    "vitest": "^4.1.1"
   }
 }

package/bin/create-creek-app.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-console.log("create-creek-app");