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

package/README.md

@@ -0,0 +1,220 @@
+# create-creek-app
+
+Scaffold a new [Creek](https://creek.dev) project from a template.
+
+```bash
+npx create-creek-app
+```
+
+## 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
+```
+
+### Template discovery
+
+```bash
+# List all templates (JSON)
+npx create-creek-app --list
+
+# Print a template's JSON Schema
+npx create-creek-app --template landing --schema
+
+# Validate data before scaffolding
+npx create-creek-app --template landing --validate --data '{"theme":"dark"}'
+```
+
+### 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
+
+| Template | Description | Capabilities |
+|----------|-------------|-------------|
+| `blank` | Minimal Creek project (no UI) | — |
+| `landing` | Landing page with hero and CTA | — |
+| `blog` | Blog with posts | D1 |
+| `link-in-bio` | Social links page | — |
+| `api` | REST API with Hono | D1 |
+| `todo` | Realtime todo app | D1, Realtime |
+| `dashboard` | Data dashboard | D1, Realtime |
+| `form` | Form collector | D1 |
+| `chatbot` | AI chatbot | D1, AI |
+
+## 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": [],
+  "thumbnail": "thumbnail.png",
+  "screenshot": "screenshot.png",
+  "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 | Required Creek resources: `d1`, `kv`, `r2`, `ai`, `realtime` |
+| `thumbnail` | string | no | Relative path to thumbnail image (400x300 recommended) |
+| `screenshot` | string | no | Relative path to full screenshot image |
+| `schema` | object | no | JSON Schema defining customizable parameters |
+
+### creek-data.json
+
+Default values for the schema parameters. The app reads this file at runtime — no build-time string replacement.
+
+```json
+{
+  "title": "My Product",
+  "tagline": "Ship faster with Creek",
+  "theme": "dark"
+}
+```
+
+## 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
+npx create-creek-app --template landing --validate --data '{"theme":"dark"}'
+# → { "valid": true, "errors": [] }
+
+# Invalid enum — fails
+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" }] }
+
+# Wrong type — fails
+npx create-creek-app --template landing --validate --data '{"title":123}'
+# → { "valid": false, "errors": [{ "path": "/title", "message": "must be string" }] }
+```
+
+## 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 (optional)
+├── creek-data.json           ← default values (optional)
+├── creek.toml                ← Creek project config
+├── package.json
+├── src/                      ← your code
+├── worker/index.ts           ← edge worker (if needed)
+└── _gitignore                ← renamed to .gitignore on scaffold
+```
+
+### Best practices
+
+1. **Use JSON Schema defaults** — every property in the schema 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 using build-time placeholders. This lets users customize after scaffold by editing one file
+3. **Keep schemas flat** — prefer top-level string/number/boolean properties. Use arrays only for naturally repeated structures (e.g., feature lists)
+4. **Use `enum` for constrained choices** — themes, layouts, color schemes. Agents can discover valid options via `--schema`
+5. **Name the `name` property** — include a `name` property in your schema. `create-creek-app` auto-populates it from the project directory
+6. **Add a thumbnail** — 400x300 PNG for template gallery display. Optional, but recommended for visual templates
+7. **Add a screenshot** — full-page screenshot showing the template in action. Optional
+8. **Use `_gitignore`** — npm strips `.gitignore` from published packages. Use `_gitignore` and it will be renamed automatically
+
+### 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
+
+# 2. Read schema for chosen template
+npx create-creek-app --template landing --schema
+
+# 3. Validate generated data
+npx create-creek-app --template landing --validate --data '{"title":"Acme","theme":"dark"}'
+
+# 4. Scaffold
+npx create-creek-app my-site --template landing --data '{"title":"Acme"}' --yes
+
+# 5. Deploy
+cd my-site && npx creek deploy
+```
+
+All discovery and validation commands output JSON to stdout for programmatic consumption.
+
+## 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,82 @@
+import { resolve, basename } from "node:path";
+import { existsSync, renameSync, 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. Rename _gitignore → .gitignore
+    const gitignoreSrc = resolve(dir, "_gitignore");
+    const gitignoreDest = resolve(dir, ".gitignore");
+    if (existsSync(gitignoreSrc)) {
+        renameSync(gitignoreSrc, gitignoreDest);
+    }
+    // 5. 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,39 @@
+/** Hardcoded template list — used for --list and interactive prompt. */
+export declare const TEMPLATES: readonly [{
+    readonly name: "blank";
+    readonly description: "Minimal Creek project (no UI)";
+    readonly capabilities: string[];
+}, {
+    readonly name: "landing";
+    readonly description: "Landing page with hero and CTA";
+    readonly capabilities: string[];
+}, {
+    readonly name: "blog";
+    readonly description: "Blog with posts (D1 database)";
+    readonly capabilities: readonly ["d1"];
+}, {
+    readonly name: "link-in-bio";
+    readonly description: "Social links page";
+    readonly capabilities: string[];
+}, {
+    readonly name: "api";
+    readonly description: "REST API with Hono (D1)";
+    readonly capabilities: readonly ["d1"];
+}, {
+    readonly name: "todo";
+    readonly description: "Realtime todo app (D1 + WebSocket)";
+    readonly capabilities: readonly ["d1", "realtime"];
+}, {
+    readonly name: "dashboard";
+    readonly description: "Data dashboard (D1 + Realtime)";
+    readonly capabilities: readonly ["d1", "realtime"];
+}, {
+    readonly name: "form";
+    readonly description: "Form collector (D1)";
+    readonly capabilities: readonly ["d1"];
+}, {
+    readonly name: "chatbot";
+    readonly description: "AI chatbot (D1 + Workers AI)";
+    readonly capabilities: readonly ["d1", "ai"];
+}];
+export type TemplateName = (typeof TEMPLATES)[number]["name"];

package/dist/templates.js

@@ -0,0 +1,12 @@
+/** Hardcoded template list — used for --list and interactive prompt. */
+export const TEMPLATES = [
+    { 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"] },
+    { name: "link-in-bio", description: "Social links page", capabilities: [] },
+    { name: "api", description: "REST API with Hono (D1)", capabilities: ["d1"] },
+    { name: "todo", description: "Realtime todo app (D1 + WebSocket)", capabilities: ["d1", "realtime"] },
+    { name: "dashboard", description: "Data dashboard (D1 + Realtime)", capabilities: ["d1", "realtime"] },
+    { name: "form", description: "Form collector (D1)", capabilities: ["d1"] },
+    { name: "chatbot", description: "AI chatbot (D1 + Workers AI)", capabilities: ["d1", "ai"] },
+];

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,46 @@
 {
   "name": "create-creek-app",
-  "version": "0.0.0-dev.0",
+  "version": "0.1.0",
+  "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"
+  ],
+  "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");