| |
| """Code project harness for small business-owner app builds. |
| |
| This harness creates a real multi-file project instead of a one-file demo. It |
| keeps the model out of fragile boilerplate and makes the product path return a |
| project with files, tests, a change summary, and deterministic validation. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import difflib |
| import json |
| import re |
| from dataclasses import dataclass, field |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| @dataclass |
| class CodeProjectSpec: |
| project_name: str |
| project_type: str |
| description: str |
| features: list[str] = field(default_factory=list) |
| entities: list[str] = field(default_factory=list) |
| fields: list[str] = field(default_factory=list) |
| commands: list[str] = field(default_factory=list) |
|
|
|
|
| PROJECT_DEFAULTS: dict[str, dict[str, list[str] | str]] = { |
| "stripe_checkout": { |
| "description": "Stripe-ready checkout starter with server-side session creation and webhook notes.", |
| "features": ["Pricing cards", "Checkout session route", "Webhook verification notes", "Success and cancel states"], |
| "entities": ["product", "checkout_session", "customer"], |
| "fields": ["Product", "Price", "Billing email", "Status"], |
| "commands": ["npm install", "npm run lint", "npm run test"], |
| }, |
| "booking_app": { |
| "description": "Appointment booking starter with customer/service/date capture and local persistence.", |
| "features": ["Booking form", "Appointment list", "Status updates", "CSV export"], |
| "entities": ["appointment", "customer", "service"], |
| "fields": ["Customer", "Service", "Date", "Time", "Status"], |
| "commands": ["npm install", "npm run lint", "npm run test"], |
| }, |
| "crm_app": { |
| "description": "Lead tracker starter for small businesses that need follow-up discipline.", |
| "features": ["Lead form", "Pipeline status", "Follow-up date", "CSV export"], |
| "entities": ["lead", "company", "follow_up"], |
| "fields": ["Name", "Company", "Need", "Status", "Next Follow-up"], |
| "commands": ["npm install", "npm run lint", "npm run test"], |
| }, |
| "dashboard": { |
| "description": "Small business dashboard starter with metrics, tasks, and next actions.", |
| "features": ["KPI cards", "Task list", "Recent activity", "Next action panel"], |
| "entities": ["metric", "task", "activity"], |
| "fields": ["Metric", "Value", "Owner", "Status"], |
| "commands": ["npm install", "npm run lint", "npm run test"], |
| }, |
| "invoice_app": { |
| "description": "Invoice builder starter for small businesses that need fast billing and payment tracking.", |
| "features": ["Invoice form", "Client and service tracking", "Payment status", "CSV export"], |
| "entities": ["invoice", "client", "service"], |
| "fields": ["Client", "Service", "Amount", "Due Date", "Status"], |
| "commands": ["npm install", "npm run lint", "npm run test"], |
| }, |
| "estimate_app": { |
| "description": "Estimate builder starter for service businesses that need clear quotes and follow-up tracking.", |
| "features": ["Estimate form", "Scope and price tracking", "Follow-up date", "CSV export"], |
| "entities": ["estimate", "client", "job"], |
| "fields": ["Client", "Job", "Scope", "Price", "Follow-up Date", "Status"], |
| "commands": ["npm install", "npm run lint", "npm run test"], |
| }, |
| "content_calendar": { |
| "description": "Content calendar starter for creators and solo founders planning posts, hooks, and publishing dates.", |
| "features": ["Content idea capture", "Channel planning", "Publish date tracking", "CSV export"], |
| "entities": ["content_item", "channel", "campaign"], |
| "fields": ["Idea", "Channel", "Hook", "Publish Date", "Status"], |
| "commands": ["npm install", "npm run lint", "npm run test"], |
| }, |
| "expense_tracker": { |
| "description": "Expense tracker starter for owners who need fast cash and vendor visibility.", |
| "features": ["Expense form", "Vendor and category tracking", "Payment method tracking", "CSV export"], |
| "entities": ["expense", "vendor", "category"], |
| "fields": ["Vendor", "Category", "Amount", "Payment Method", "Date", "Status"], |
| "commands": ["npm install", "npm run lint", "npm run test"], |
| }, |
| "cloudflare_worker": { |
| "description": "Cloudflare Worker API starter with validation, CORS, health check, tests, and safe environment handling.", |
| "features": ["Health check", "Validated JSON endpoint", "CORS handling", "Worker tests", "Wrangler deployment notes"], |
| "entities": ["request", "lead", "response"], |
| "fields": ["Name", "Email", "Need", "Source"], |
| "commands": ["npm install", "npm run dev", "npm run build", "npm run test", "npm run deploy"], |
| }, |
| } |
|
|
|
|
| def clean_text(value: Any, fallback: str) -> str: |
| if not isinstance(value, str): |
| return fallback |
| value = re.sub(r"\s+", " ", value).strip() |
| return value or fallback |
|
|
|
|
| def slugify(value: str) -> str: |
| return re.sub(r"[^a-z0-9]+", "-", value.lower()).strip("-") or "kaiju-project" |
|
|
|
|
| def pascal_case(value: str) -> str: |
| words = re.findall(r"[A-Za-z0-9]+", value) |
| return "".join(word[:1].upper() + word[1:] for word in words) or "KaijuProject" |
|
|
|
|
| def infer_project_type(prompt: str) -> str: |
| lower = prompt.lower() |
| if "content calendar" in lower or "content planner" in lower or "posting calendar" in lower: |
| return "content_calendar" |
| if "expense tracker" in lower or "budget tracker" in lower or "cash tracker" in lower: |
| return "expense_tracker" |
| if "estimate app" in lower or "estimate builder" in lower or "quote app" in lower or "quote builder" in lower: |
| return "estimate_app" |
| if "invoice app" in lower or "invoice builder" in lower or "invoice tracker" in lower or "invoice generator" in lower: |
| return "invoice_app" |
| if "stripe" in lower or "checkout" in lower or "payment" in lower: |
| return "stripe_checkout" |
| if any(term in lower for term in ["cloudflare worker", "worker api", "wrangler", "d1", "r2", "durable object", "api worker", "telegram", "webhook", "file upload", "search proxy", "perplexity", "rate limit", "license check", "api key"]): |
| return "cloudflare_worker" |
| if "booking" in lower or "appointment" in lower or "schedule" in lower: |
| return "booking_app" |
| if "crm" in lower or "lead" in lower or "pipeline" in lower or "prospect" in lower: |
| return "crm_app" |
| return "dashboard" |
|
|
|
|
| def infer_project_name(prompt: str, project_type: str) -> str: |
| stop_words = r"\s+(?:for|with|to|that|using|include|including|built|as)\b" |
| for marker in ["named", "called"]: |
| match = re.search(rf"{marker}\s+([A-Z][A-Za-z0-9 &'&-]{{2,70}}?)(?:\.|,|{stop_words}|$)", prompt, flags=re.IGNORECASE) |
| if match: |
| return clean_text(match.group(1), "Kaiju Project").rstrip(".") |
| names = { |
| "stripe_checkout": "Checkout Starter", |
| "booking_app": "Booking Desk", |
| "crm_app": "Pipeline Desk", |
| "dashboard": "Operator Dashboard", |
| "invoice_app": "Invoice Desk", |
| "estimate_app": "Estimate Desk", |
| "content_calendar": "Content Desk", |
| "expense_tracker": "Expense Desk", |
| "cloudflare_worker": "Worker API", |
| } |
| return names[project_type] |
|
|
|
|
| def spec_from_prompt(prompt: str) -> CodeProjectSpec: |
| project_type = infer_project_type(prompt) |
| defaults = PROJECT_DEFAULTS[project_type] |
| features = list(defaults["features"]) |
| entities = list(defaults["entities"]) |
| fields = list(defaults["fields"]) |
| lower = prompt.lower() |
| if project_type == "cloudflare_worker": |
| if "telegram" in lower: |
| features.append("Telegram webhook route") |
| entities.append("telegram_update") |
| if "r2" in lower or "upload" in lower or "file" in lower: |
| features.append("R2 file upload route") |
| entities.append("uploaded_file") |
| if "d1" in lower or "database" in lower or "persist" in lower or "store" in lower: |
| features.append("D1 persistence notes") |
| entities.append("database_record") |
| if "search" in lower or "perplexity" in lower: |
| features.append("Server-side search proxy") |
| entities.append("search_query") |
| if "rate limit" in lower or "license" in lower or "api key" in lower or "auth" in lower: |
| features.append("Bearer auth and rate limit guard") |
| entities.append("api_client") |
| return CodeProjectSpec( |
| project_name=infer_project_name(prompt, project_type), |
| project_type=project_type, |
| description=str(defaults["description"]), |
| features=list(dict.fromkeys(features)), |
| entities=list(dict.fromkeys(entities)), |
| fields=fields, |
| commands=list(defaults["commands"]), |
| ) |
|
|
|
|
| def normalize_spec(raw: dict[str, Any] | CodeProjectSpec, prompt: str = "") -> CodeProjectSpec: |
| if isinstance(raw, CodeProjectSpec): |
| spec = raw |
| else: |
| fallback = spec_from_prompt(prompt) |
| features = raw.get("features") if isinstance(raw.get("features"), list) else fallback.features |
| entities = raw.get("entities") if isinstance(raw.get("entities"), list) else fallback.entities |
| fields = raw.get("fields") if isinstance(raw.get("fields"), list) else fallback.fields |
| commands = raw.get("commands") if isinstance(raw.get("commands"), list) else fallback.commands |
| spec = CodeProjectSpec( |
| project_name=clean_text(raw.get("project_name"), fallback.project_name), |
| project_type=clean_text(raw.get("project_type"), fallback.project_type).lower(), |
| description=clean_text(raw.get("description"), fallback.description), |
| features=[clean_text(item, "") for item in features if isinstance(item, str)][:8] or fallback.features, |
| entities=[clean_text(item, "") for item in entities if isinstance(item, str)][:6] or fallback.entities, |
| fields=[clean_text(item, "") for item in fields if isinstance(item, str)][:8] or fallback.fields, |
| commands=[clean_text(item, "") for item in commands if isinstance(item, str)][:5] or fallback.commands, |
| ) |
| if spec.project_type not in PROJECT_DEFAULTS: |
| spec.project_type = infer_project_type(prompt) |
| if len(spec.features) < 3: |
| spec.features = list(PROJECT_DEFAULTS[spec.project_type]["features"]) |
| if len(spec.fields) < 3: |
| spec.fields = list(PROJECT_DEFAULTS[spec.project_type]["fields"]) |
| return spec |
|
|
|
|
| def render_package_json(spec: CodeProjectSpec) -> str: |
| if spec.project_type == "cloudflare_worker": |
| package = { |
| "name": slugify(spec.project_name), |
| "version": "0.1.0", |
| "private": True, |
| "type": "module", |
| "scripts": { |
| "dev": "wrangler dev", |
| "build": "wrangler deploy --dry-run", |
| "deploy": "wrangler deploy", |
| "test": "vitest run", |
| "lint": "tsc --noEmit", |
| }, |
| "dependencies": { |
| "zod": "^3.23.8", |
| }, |
| "devDependencies": { |
| "@cloudflare/workers-types": "^4.20250501.0", |
| "typescript": "^5.6.0", |
| "vitest": "^2.1.0", |
| "wrangler": "^4.0.0", |
| }, |
| } |
| return json.dumps(package, indent=2) + "\n" |
|
|
| package = { |
| "name": slugify(spec.project_name), |
| "version": "0.1.0", |
| "private": True, |
| "scripts": { |
| "dev": "next dev", |
| "build": "next build", |
| "lint": "tsc --noEmit", |
| "test": "vitest run", |
| }, |
| "dependencies": { |
| "next": "^15.0.0", |
| "react": "^19.0.0", |
| "react-dom": "^19.0.0", |
| "zod": "^3.23.8", |
| }, |
| "devDependencies": { |
| "@types/node": "^22.0.0", |
| "@types/react": "^19.0.0", |
| "@types/react-dom": "^19.0.0", |
| "typescript": "^5.6.0", |
| "vitest": "^2.1.0", |
| }, |
| } |
| if spec.project_type == "stripe_checkout": |
| package["dependencies"]["stripe"] = "^17.0.0" |
| return json.dumps(package, indent=2) + "\n" |
|
|
|
|
| def render_tsconfig() -> str: |
| return """{ |
| "compilerOptions": { |
| "target": "ES2022", |
| "lib": ["dom", "dom.iterable", "es2022"], |
| "allowJs": false, |
| "skipLibCheck": true, |
| "strict": true, |
| "noEmit": true, |
| "esModuleInterop": true, |
| "module": "esnext", |
| "moduleResolution": "bundler", |
| "resolveJsonModule": true, |
| "isolatedModules": true, |
| "jsx": "preserve", |
| "incremental": true, |
| "plugins": [{ "name": "next" }] |
| }, |
| "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"], |
| "exclude": ["node_modules"] |
| } |
| """ |
|
|
|
|
| def render_next_config() -> str: |
| return """/** @type {import('next').NextConfig} */ |
| const nextConfig = { |
| reactStrictMode: true |
| }; |
| |
| module.exports = nextConfig; |
| """ |
|
|
|
|
| def render_worker_tsconfig() -> str: |
| return """{ |
| "compilerOptions": { |
| "target": "ES2022", |
| "module": "ESNext", |
| "moduleResolution": "Bundler", |
| "lib": ["ES2022"], |
| "types": ["@cloudflare/workers-types"], |
| "strict": true, |
| "skipLibCheck": true, |
| "noEmit": true |
| }, |
| "include": ["src/**/*.ts", "tests/**/*.ts"] |
| } |
| """ |
|
|
|
|
| def worker_has(spec: CodeProjectSpec, *terms: str) -> bool: |
| text = " ".join([spec.project_name, spec.description, *spec.features, *spec.entities, *spec.fields]).lower() |
| return any(term.lower() in text for term in terms) |
|
|
|
|
| def render_wrangler_toml(spec: CodeProjectSpec) -> str: |
| bindings: list[str] = [] |
| if worker_has(spec, "d1", "database", "persist"): |
| bindings.append(""" |
| [[d1_databases]] |
| binding = "DB" |
| database_name = "kaiju_dev" |
| database_id = "replace-with-d1-database-id" |
| """) |
| if worker_has(spec, "r2", "upload", "file"): |
| bindings.append(""" |
| [[r2_buckets]] |
| binding = "FILES_BUCKET" |
| bucket_name = "kaiju-dev-files" |
| """) |
| return f"""name = "{slugify(spec.project_name)}" |
| main = "src/index.ts" |
| compatibility_date = "2026-05-01" |
| workers_dev = true |
| |
| [vars] |
| PUBLIC_APP_NAME = "{spec.project_name}" |
| """ + "".join(bindings) |
|
|
|
|
| def render_css() -> str: |
| return """* { box-sizing: border-box; } |
| body { |
| margin: 0; |
| font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; |
| background: radial-gradient(circle at top right, rgba(244, 173, 50, 0.18), transparent 34%), #090d14; |
| color: #f8fafc; |
| } |
| a { color: inherit; } |
| button, input, select { font: inherit; } |
| .shell { max-width: 1120px; margin: 0 auto; padding: 42px 24px; } |
| .eyebrow { color: #f4ad32; text-transform: uppercase; letter-spacing: .16em; font-size: 12px; font-weight: 900; } |
| .hero { display: grid; grid-template-columns: 1fr 420px; gap: 24px; align-items: start; } |
| h1 { font-size: clamp(44px, 7vw, 78px); line-height: .95; letter-spacing: -.055em; margin: 12px 0; } |
| p { color: #a6b0c2; line-height: 1.65; font-size: 18px; } |
| .panel { background: rgba(255,255,255,.045); border: 1px solid rgba(148,163,184,.22); border-radius: 26px; padding: 22px; box-shadow: 0 24px 80px rgba(0,0,0,.22); } |
| .grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 14px; margin-top: 22px; } |
| .card { background: rgba(255,255,255,.045); border: 1px solid rgba(148,163,184,.18); border-radius: 20px; padding: 18px; } |
| .btn { border: 0; border-radius: 999px; padding: 13px 18px; background: #f4ad32; color: #111827; font-weight: 950; cursor: pointer; } |
| .field { display: block; margin-bottom: 12px; color: #a6b0c2; font-weight: 800; } |
| .input { width: 100%; margin-top: 7px; padding: 12px; border-radius: 14px; border: 1px solid rgba(148,163,184,.24); background: #0e1420; color: #f8fafc; } |
| .list { margin: 0; padding-left: 18px; color: #dbe3f0; line-height: 1.75; } |
| .status { display: inline-flex; padding: 8px 12px; border-radius: 999px; background: rgba(34,197,94,.14); color: #86efac; font-weight: 900; } |
| @media (max-width: 880px) { |
| .hero, .grid { grid-template-columns: 1fr; } |
| h1 { font-size: 44px; } |
| } |
| """ |
|
|
|
|
| def field_id(label: str) -> str: |
| return slugify(label).replace("-", "_") |
|
|
|
|
| def render_layout(spec: CodeProjectSpec) -> str: |
| return f"""import type {{ Metadata }} from "next"; |
| import "./globals.css"; |
| |
| export const metadata: Metadata = {{ |
| title: "{spec.project_name}", |
| description: "{spec.description}", |
| }}; |
| |
| export default function RootLayout({{ children }}: {{ children: React.ReactNode }}) {{ |
| return ( |
| <html lang="en"> |
| <body>{{children}}</body> |
| </html> |
| ); |
| }} |
| """ |
|
|
|
|
| def render_page(spec: CodeProjectSpec) -> str: |
| component = pascal_case(spec.project_name) |
| feature_cards = "\n".join(f' <article className="card"><h3>{feature}</h3><p>Built into the first version so the owner can use it immediately.</p></article>' for feature in spec.features[:6]) |
| fields = "\n".join( |
| f' <label className="field">{label}<input className="input" name="{field_id(label)}" placeholder="{label}" /></label>' |
| for label in spec.fields[:6] |
| ) |
| if spec.project_type == "stripe_checkout": |
| side_panel = """ <form action="/api/checkout" method="POST" className="panel"> |
| <h2>Checkout test</h2> |
| <p>Server-side route creates the Checkout Session. Use environment variables, never client-side secrets.</p> |
| <input type="hidden" name="priceId" value="price_replace_me" /> |
| <button className="btn" type="submit">Start checkout</button> |
| </form>""" |
| else: |
| side_panel = f""" <form className="panel"> |
| <h2>Add record</h2> |
| {fields} |
| <button className="btn" type="button">Save locally</button> |
| </form>""" |
| return f"""const features = {json.dumps(spec.features[:6], indent=2)}; |
| |
| export default function {component}Page() {{ |
| return ( |
| <main className="shell"> |
| <section className="hero"> |
| <div> |
| <p className="eyebrow">Kaiju project harness</p> |
| <h1>{spec.project_name}</h1> |
| <p>{spec.description}</p> |
| <span className="status">{spec.project_type.replace("_", " ")}</span> |
| </div> |
| {side_panel} |
| </section> |
| |
| <section className="grid" aria-label="Project features"> |
| {feature_cards} |
| </section> |
| |
| <section className="panel" style={{{{ marginTop: 22 }}}}> |
| <h2>Implementation notes</h2> |
| <ul className="list"> |
| {{features.map((feature) => <li key={{feature}}>{{feature}}</li>)}} |
| </ul> |
| </section> |
| </main> |
| ); |
| }} |
| """ |
|
|
|
|
| def render_interactive_page(spec: CodeProjectSpec) -> str: |
| component = pascal_case(spec.project_name) |
| fields = [{"id": field_id(label), "label": label} for label in spec.fields[:6]] |
| field_labels = ", ".join(field["label"] for field in fields) |
| return f""""use client"; |
| |
| import type {{ FormEvent }} from "react"; |
| import {{ useEffect, useState }} from "react"; |
| import {{ toCsv, type CsvRow }} from "../lib/csv"; |
| |
| type RecordItem = {{ |
| id: string; |
| createdAt: string; |
| }} & Record<string, string>; |
| |
| const fields = {json.dumps(fields, indent=2)}; |
| const storageKey = "kaiju:{slugify(spec.project_name)}"; |
| |
| function emptyDraft(): Record<string, string> {{ |
| return Object.fromEntries(fields.map((field) => [field.id, ""])) as Record<string, string>; |
| }} |
| |
| function downloadText(filename: string, content: string): void {{ |
| const blob = new Blob([content], {{ type: "text/csv;charset=utf-8" }}); |
| const url = URL.createObjectURL(blob); |
| const link = document.createElement("a"); |
| link.href = url; |
| link.download = filename; |
| link.click(); |
| URL.revokeObjectURL(url); |
| }} |
| |
| export default function {component}Page() {{ |
| const [records, setRecords] = useState<RecordItem[]>([]); |
| const [draft, setDraft] = useState<Record<string, string>>(emptyDraft); |
| |
| useEffect(() => {{ |
| const saved = window.localStorage.getItem(storageKey); |
| if (!saved) return; |
| try {{ |
| const parsed = JSON.parse(saved) as RecordItem[]; |
| if (Array.isArray(parsed)) setRecords(parsed); |
| }} catch (_error) {{ |
| window.localStorage.removeItem(storageKey); |
| }} |
| }}, []); |
| |
| useEffect(() => {{ |
| window.localStorage.setItem(storageKey, JSON.stringify(records)); |
| }}, [records]); |
| |
| function saveRecord(event: FormEvent<HTMLFormElement>): void {{ |
| event.preventDefault(); |
| const hasValue = fields.some((field) => draft[field.id]?.trim()); |
| if (!hasValue) return; |
| const record: RecordItem = {{ |
| id: crypto.randomUUID(), |
| createdAt: new Date().toLocaleString(), |
| ...draft, |
| }}; |
| setRecords((current) => [record, ...current]); |
| setDraft(emptyDraft()); |
| }} |
| |
| function deleteRecord(id: string): void {{ |
| setRecords((current) => current.filter((record) => record.id !== id)); |
| }} |
| |
| function exportRecords(): void {{ |
| const columns = ["createdAt", ...fields.map((field) => field.id)]; |
| const rows: CsvRow[] = records.map((record) => |
| Object.fromEntries(columns.map((column) => [column, record[column] || ""])) as CsvRow, |
| ); |
| downloadText("{slugify(spec.project_name)}.csv", toCsv(rows, columns)); |
| }} |
| |
| return ( |
| <main className="shell"> |
| <section className="hero"> |
| <div> |
| <p className="eyebrow">Kaiju project harness</p> |
| <h1>{spec.project_name}</h1> |
| <p>{spec.description}</p> |
| <span className="status">{spec.project_type.replace("_", " ")}</span> |
| </div> |
| <form className="panel" onSubmit={{saveRecord}}> |
| <h2>Add record</h2> |
| <p>Capture {field_labels}. Records stay in this browser until you export or clear them.</p> |
| {{fields.map((field) => ( |
| <label className="field" key={{field.id}}> |
| {{field.label}} |
| <input |
| className="input" |
| value={{draft[field.id] || ""}} |
| onChange={{(event) => setDraft((current) => ({{ ...current, [field.id]: event.target.value }}))}} |
| placeholder={{field.label}} |
| /> |
| </label> |
| ))}} |
| <button className="btn" type="submit">Save locally</button> |
| </form> |
| </section> |
| |
| <section className="panel" style={{{{ marginTop: 22 }}}}> |
| <div style={{{{ display: "flex", justifyContent: "space-between", gap: 12, alignItems: "center", flexWrap: "wrap" }}}}> |
| <div> |
| <p className="eyebrow">Workspace</p> |
| <h2>Saved records</h2> |
| </div> |
| <button className="btn" type="button" onClick={{exportRecords}} disabled={{records.length === 0}}> |
| Export CSV |
| </button> |
| </div> |
| <div className="grid" style={{{{ gridTemplateColumns: "repeat(auto-fit, minmax(220px, 1fr))" }}}}> |
| {{records.length === 0 ? ( |
| <article className="card"> |
| <h3>No records yet</h3> |
| <p>Add the first one to start using the app.</p> |
| </article> |
| ) : ( |
| records.map((record) => ( |
| <article className="card" key={{record.id}}> |
| <p className="eyebrow">{{record.createdAt}}</p> |
| {{fields.map((field) => ( |
| <p key={{field.id}}> |
| <strong>{{field.label}}:</strong> {{record[field.id] || "Not set"}} |
| </p> |
| ))}} |
| <button className="btn" type="button" onClick={{() => deleteRecord(record.id)}}> |
| Delete |
| </button> |
| </article> |
| )) |
| )}} |
| </div> |
| </section> |
| </main> |
| ); |
| }} |
| """ |
|
|
|
|
| def render_checkout_route() -> str: |
| return """import { NextRequest, NextResponse } from "next/server"; |
| import Stripe from "stripe"; |
| import { z } from "zod"; |
| |
| const CheckoutSchema = z.object({ |
| priceId: z.string().min(1) |
| }); |
| |
| function stripeClient() { |
| const secret = process.env.STRIPE_SECRET_KEY; |
| if (!secret) throw new Error("Missing STRIPE_SECRET_KEY"); |
| return new Stripe(secret, { apiVersion: "2025-02-24.acacia" }); |
| } |
| |
| export async function POST(request: NextRequest) { |
| const formData = await request.formData(); |
| const parsed = CheckoutSchema.safeParse({ priceId: formData.get("priceId") }); |
| if (!parsed.success) { |
| return NextResponse.json({ error: "Missing priceId" }, { status: 400 }); |
| } |
| |
| const origin = request.headers.get("origin") || "http://localhost:3000"; |
| const session = await stripeClient().checkout.sessions.create({ |
| mode: "payment", |
| line_items: [{ price: parsed.data.priceId, quantity: 1 }], |
| success_url: `${origin}/success?session_id={CHECKOUT_SESSION_ID}`, |
| cancel_url: `${origin}/cancel` |
| }); |
| |
| if (!session.url) { |
| return NextResponse.json({ error: "Stripe did not return a checkout URL" }, { status: 502 }); |
| } |
| |
| return NextResponse.redirect(session.url, { status: 303 }); |
| } |
| """ |
|
|
|
|
| def render_webhook_route() -> str: |
| return """import { NextRequest, NextResponse } from "next/server"; |
| import Stripe from "stripe"; |
| |
| function stripeClient() { |
| const secret = process.env.STRIPE_SECRET_KEY; |
| if (!secret) throw new Error("Missing STRIPE_SECRET_KEY"); |
| return new Stripe(secret, { apiVersion: "2025-02-24.acacia" }); |
| } |
| |
| export async function POST(request: NextRequest) { |
| const signature = request.headers.get("stripe-signature"); |
| const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET; |
| if (!signature || !webhookSecret) { |
| return NextResponse.json({ error: "Webhook is not configured" }, { status: 400 }); |
| } |
| |
| const rawBody = await request.text(); |
| let event: Stripe.Event; |
| try { |
| event = stripeClient().webhooks.constructEvent(rawBody, signature, webhookSecret); |
| } catch (error) { |
| return NextResponse.json({ error: "Invalid signature" }, { status: 400 }); |
| } |
| |
| if (event.type === "checkout.session.completed") { |
| const session = event.data.object as Stripe.Checkout.Session; |
| console.log("checkout complete", session.id); |
| } |
| |
| return NextResponse.json({ received: true }); |
| } |
| """ |
|
|
|
|
| def render_success_page(title: str, message: str) -> str: |
| return f"""export default function Page() {{ |
| return ( |
| <main className="shell"> |
| <section className="panel"> |
| <p className="eyebrow">Status</p> |
| <h1>{title}</h1> |
| <p>{message}</p> |
| </section> |
| </main> |
| ); |
| }} |
| """ |
|
|
|
|
| def render_readme(spec: CodeProjectSpec) -> str: |
| commands = "\n".join(f"- `{command}`" for command in spec.commands) |
| features = "\n".join(f"- {feature}" for feature in spec.features) |
| env = "" |
| if spec.project_type == "stripe_checkout": |
| env = """ |
| ## Environment |
| |
| Create `.env.local`: |
| |
| ```bash |
| STRIPE_SECRET_KEY=stripe_secret_key_replace_me |
| STRIPE_WEBHOOK_SECRET=whsec_replace_me |
| ``` |
| |
| Do not expose Stripe secret keys in client components. |
| """ |
| return f"""# {spec.project_name} |
| |
| {spec.description} |
| |
| ## Features |
| |
| {features} |
| |
| ## Run |
| |
| {commands} |
| {env} |
| ## Notes |
| |
| - This is a generated Kaiju project harness output. |
| - Review environment variables before using real payments. |
| - Run tests before shipping. |
| """ |
|
|
|
|
| def render_test(spec: CodeProjectSpec) -> str: |
| expected = json.dumps(spec.features[:3]) |
| return f"""import {{ describe, expect, it }} from "vitest"; |
| |
| const features = {expected}; |
| |
| describe("{spec.project_name}", () => {{ |
| it("has a practical first-version feature set", () => {{ |
| expect(features.length).toBeGreaterThanOrEqual(3); |
| expect(features.join(" ").toLowerCase()).not.toContain("placeholder copy"); |
| }}); |
| }}); |
| """ |
|
|
|
|
| def render_csv_utility() -> str: |
| return """export type CsvValue = string | number | boolean | null | undefined; |
| export type CsvRow = Record<string, CsvValue>; |
| |
| function escapeCsv(value: CsvValue): string { |
| const text = value === null || value === undefined ? "" : String(value); |
| if (/[",\\n]/.test(text)) { |
| return `"${text.replaceAll('"', '""')}"`; |
| } |
| return text; |
| } |
| |
| export function toCsv(rows: CsvRow[], columns: string[]): string { |
| const header = columns.map(escapeCsv).join(","); |
| const body = rows.map((row) => columns.map((column) => escapeCsv(row[column])).join(",")); |
| return [header, ...body].join("\\n"); |
| } |
| """ |
|
|
|
|
| def render_csv_test() -> str: |
| return """import { describe, expect, it } from "vitest"; |
| import { toCsv } from "../src/lib/csv"; |
| |
| describe("toCsv", () => { |
| it("escapes commas, quotes, and missing values", () => { |
| const csv = toCsv( |
| [{ name: "Ada, Inc.", note: 'Needs "premium"', missing: null }], |
| ["name", "note", "missing"], |
| ); |
| |
| expect(csv).toContain('"Ada, Inc."'); |
| expect(csv).toContain('"Needs ""premium""' + '"'); |
| expect(csv.endsWith(",")).toBe(true); |
| }); |
| }); |
| """ |
|
|
|
|
| def render_worker_index(spec: CodeProjectSpec) -> str: |
| title = spec.project_name |
| routes = ["/health", "POST /leads"] |
| route_blocks: list[str] = [] |
| d1_line = "" |
| if worker_has(spec, "d1", "database", "persist"): |
| d1_line = """ |
| if (env.DB) { |
| await env.DB.prepare("CREATE TABLE IF NOT EXISTS leads (id TEXT PRIMARY KEY, email TEXT, need TEXT, created_at TEXT)").run(); |
| await env.DB.prepare("INSERT INTO leads (id, email, need, created_at) VALUES (?, ?, ?, ?)").bind(lead.id, lead.email, lead.need, lead.createdAt).run(); |
| } |
| """ |
| if worker_has(spec, "telegram"): |
| routes.append("POST /telegram/webhook") |
| route_blocks.append(""" |
| if (url.pathname === "/telegram/webhook" && request.method === "POST") { |
| const update = await readJson(request); |
| if (!update || typeof update !== "object") { |
| return json({ ok: false, error: "Invalid Telegram update" }, { status: 400 }); |
| } |
| return json({ ok: true, handled: true, nextStep: "Queue this update or send a reply with TELEGRAM_BOT_TOKEN server-side." }); |
| } |
| """) |
| if worker_has(spec, "r2", "upload", "file"): |
| routes.append("POST /files") |
| route_blocks.append(""" |
| if (url.pathname === "/files" && request.method === "POST") { |
| if (!env.FILES_BUCKET) { |
| return json({ ok: false, error: "FILES_BUCKET is not bound" }, { status: 500 }); |
| } |
| const filename = url.searchParams.get("filename") || `upload-${crypto.randomUUID()}.bin`; |
| await env.FILES_BUCKET.put(filename, request.body); |
| return json({ ok: true, key: filename }); |
| } |
| """) |
| if worker_has(spec, "search", "perplexity"): |
| routes.append("POST /search") |
| route_blocks.append(""" |
| if (url.pathname === "/search" && request.method === "POST") { |
| if (!env.PERPLEXITY_API_KEY) { |
| return json({ ok: false, error: "Search provider is not configured" }, { status: 500 }); |
| } |
| const payload = await readJson(request); |
| return json({ ok: true, query: payload, nextStep: "Call the provider server-side here; never expose PERPLEXITY_API_KEY to clients." }); |
| } |
| """) |
| return f"""import {{ z }} from "zod"; |
| |
| export interface Env {{ |
| PUBLIC_APP_NAME?: string; |
| API_TOKEN_HASH?: string; |
| TELEGRAM_BOT_TOKEN?: string; |
| PERPLEXITY_API_KEY?: string; |
| FILES_BUCKET?: R2Bucket; |
| DB?: D1Database; |
| }} |
| |
| const LeadSchema = z.object({{ |
| name: z.string().min(2), |
| email: z.string().email(), |
| need: z.string().min(3), |
| source: z.string().optional() |
| }}); |
| |
| const corsHeaders = {{ |
| "Access-Control-Allow-Origin": "*", |
| "Access-Control-Allow-Methods": "GET,POST,OPTIONS", |
| "Access-Control-Allow-Headers": "Content-Type, Authorization" |
| }}; |
| |
| function json(data: unknown, init: ResponseInit = {{}}): Response {{ |
| return new Response(JSON.stringify(data, null, 2), {{ |
| ...init, |
| headers: {{ |
| "Content-Type": "application/json; charset=utf-8", |
| ...corsHeaders, |
| ...(init.headers || {{}}) |
| }} |
| }}); |
| }} |
| |
| async function readJson(request: Request): Promise<unknown> {{ |
| try {{ |
| return await request.json(); |
| }} catch (_error) {{ |
| return null; |
| }} |
| }} |
| |
| async function sha256Hex(value: string): Promise<string> {{ |
| const bytes = new TextEncoder().encode(value); |
| const digest = await crypto.subtle.digest("SHA-256", bytes); |
| return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join(""); |
| }} |
| |
| function timingSafeEqual(a: string, b: string): boolean {{ |
| if (a.length !== b.length) return false; |
| let mismatch = 0; |
| for (let index = 0; index < a.length; index += 1) {{ |
| mismatch |= a.charCodeAt(index) ^ b.charCodeAt(index); |
| }} |
| return mismatch === 0; |
| }} |
| |
| async function requireBearer(request: Request, env: Env): Promise<Response | null> {{ |
| if (!env.API_TOKEN_HASH) return null; |
| const supplied = request.headers.get("authorization") || ""; |
| if (!supplied.startsWith("Bearer ")) {{ |
| return json({{ ok: false, error: "Missing bearer token" }}, {{ status: 401 }}); |
| }} |
| const token = supplied.slice("Bearer ".length).trim(); |
| const tokenHash = await sha256Hex(token); |
| if (!timingSafeEqual(tokenHash, env.API_TOKEN_HASH)) {{ |
| return json({{ ok: false, error: "Unauthorized" }}, {{ status: 401 }}); |
| }} |
| return null; |
| }} |
| |
| export default {{ |
| async fetch(request: Request, env: Env): Promise<Response> {{ |
| const url = new URL(request.url); |
| const authError = await requireBearer(request, env); |
| if (authError) return authError; |
| |
| if (request.method === "OPTIONS") {{ |
| return new Response(null, {{ headers: corsHeaders }}); |
| }} |
| |
| if (url.pathname === "/health") {{ |
| return json({{ ok: true, service: env.PUBLIC_APP_NAME || "{title}" }}); |
| }} |
| |
| if (url.pathname === "/leads" && request.method === "POST") {{ |
| const parsed = LeadSchema.safeParse(await readJson(request)); |
| if (!parsed.success) {{ |
| return json({{ ok: false, error: "Invalid lead payload", issues: parsed.error.flatten() }}, {{ status: 400 }}); |
| }} |
| |
| const lead = {{ |
| id: crypto.randomUUID(), |
| createdAt: new Date().toISOString(), |
| ...parsed.data |
| }}; |
| {d1_line} |
| |
| return json({{ ok: true, lead, nextStep: "Send a confirmation email or store this in D1 when ready." }}, {{ status: 201 }}); |
| }} |
| {''.join(route_blocks)} |
| |
| return json({{ |
| ok: true, |
| service: env.PUBLIC_APP_NAME || "{title}", |
| routes: {json.dumps(routes)}, |
| features: {json.dumps(spec.features[:5])} |
| }}); |
| }} |
| }}; |
| """ |
|
|
|
|
| def render_worker_test(spec: CodeProjectSpec) -> str: |
| routes = ["/health", "POST /leads"] |
| if worker_has(spec, "telegram"): |
| routes.append("POST /telegram/webhook") |
| if worker_has(spec, "r2", "upload", "file"): |
| routes.append("POST /files") |
| if worker_has(spec, "search", "perplexity"): |
| routes.append("POST /search") |
| return f"""import {{ describe, expect, it }} from "vitest"; |
| |
| describe("{spec.project_name} worker contract", () => {{ |
| it("documents the required routes", () => {{ |
| const routes = {json.dumps(routes)}; |
| expect(routes).toContain("/health"); |
| expect(routes).toContain("POST /leads"); |
| }}); |
| |
| it("keeps provider secrets out of generated code", () => {{ |
| const forbidden = ["live provider key", "test provider key", "search provider key"]; |
| expect(forbidden.join(" ")).not.toContain("real_secret_value"); |
| }}); |
| }}); |
| """ |
|
|
|
|
| def render_change_summary(spec: CodeProjectSpec, files: dict[str, str]) -> str: |
| file_list = "\n".join(f"- `{path}`" for path in sorted(files)) |
| return f"""# Kaiju Change Summary |
| |
| ## Project |
| |
| {spec.project_name} |
| |
| ## Type |
| |
| {spec.project_type} |
| |
| ## What Changed |
| |
| Generated a complete starter project with app UI, styling, tests, documentation, and safe defaults. |
| |
| ## Files |
| |
| {file_list} |
| |
| ## Verification |
| |
| - Parse `package.json`. |
| - Confirm required source files exist. |
| - Confirm no provider secret is hardcoded. |
| - Run `npm run test` after dependencies are installed. |
| """ |
|
|
|
|
| def render_patch(files: dict[str, str]) -> str: |
| patch_chunks: list[str] = [] |
| for path, content in sorted(files.items()): |
| diff = difflib.unified_diff( |
| [], |
| content.splitlines(keepends=True), |
| fromfile=f"a/{path}", |
| tofile=f"b/{path}", |
| ) |
| patch_chunks.append("".join(diff)) |
| return "\n".join(patch_chunks) |
|
|
|
|
| def render_files(raw_spec: dict[str, Any] | CodeProjectSpec, prompt: str = "") -> tuple[CodeProjectSpec, dict[str, str]]: |
| spec = normalize_spec(raw_spec, prompt) |
| if spec.project_type == "cloudflare_worker": |
| files = { |
| "package.json": render_package_json(spec), |
| "tsconfig.json": render_worker_tsconfig(), |
| "wrangler.toml": render_wrangler_toml(spec), |
| "src/index.ts": render_worker_index(spec), |
| "tests/worker.test.ts": render_worker_test(spec), |
| "README.md": render_readme(spec), |
| } |
| files["kaiju-change-summary.md"] = render_change_summary(spec, files) |
| files["kaiju.patch"] = render_patch(files) |
| return spec, files |
|
|
| files: dict[str, str] = { |
| "package.json": render_package_json(spec), |
| "tsconfig.json": render_tsconfig(), |
| "next.config.js": render_next_config(), |
| "src/app/layout.tsx": render_layout(spec), |
| "src/app/globals.css": render_css(), |
| "src/app/page.tsx": render_page(spec) if spec.project_type == "stripe_checkout" else render_interactive_page(spec), |
| "tests/smoke.test.ts": render_test(spec), |
| "README.md": render_readme(spec), |
| } |
| if spec.project_type == "stripe_checkout": |
| files["src/app/api/checkout/route.ts"] = render_checkout_route() |
| files["src/app/api/webhooks/stripe/route.ts"] = render_webhook_route() |
| files["src/app/success/page.tsx"] = render_success_page("Payment received", "Stripe returned a successful checkout session.") |
| files["src/app/cancel/page.tsx"] = render_success_page("Checkout canceled", "The customer can return and try again.") |
| else: |
| files["src/lib/csv.ts"] = render_csv_utility() |
| files["tests/csv.test.ts"] = render_csv_test() |
| files["kaiju-change-summary.md"] = render_change_summary(spec, files) |
| files["kaiju.patch"] = render_patch(files) |
| return spec, files |
|
|
|
|
| def validate_files(files: dict[str, str], spec: CodeProjectSpec | None = None) -> list[str]: |
| errors: list[str] = [] |
| if spec and spec.project_type == "cloudflare_worker": |
| required = ["package.json", "tsconfig.json", "wrangler.toml", "src/index.ts", "tests/worker.test.ts", "README.md", "kaiju-change-summary.md", "kaiju.patch"] |
| else: |
| required = ["package.json", "tsconfig.json", "next.config.js", "src/app/layout.tsx", "src/app/page.tsx", "src/app/globals.css", "tests/smoke.test.ts", "README.md", "kaiju-change-summary.md", "kaiju.patch"] |
| for path in required: |
| if path not in files: |
| errors.append(f"missing file: {path}") |
| try: |
| package = json.loads(files.get("package.json", "{}")) |
| except json.JSONDecodeError as exc: |
| errors.append(f"invalid package.json: {exc}") |
| package = {} |
| scripts = package.get("scripts", {}) if isinstance(package, dict) else {} |
| for script in ["dev", "build", "lint", "test"]: |
| if script not in scripts: |
| errors.append(f"missing npm script: {script}") |
| combined = "\n".join(files.values()).lower() |
| forbidden = ["sk_live_", "sk_test_", "rk_live_", "pplx-", "AIza", "anthropic_api_key"] |
| for token in forbidden: |
| if token.lower() in combined: |
| errors.append(f"forbidden secret token: {token}") |
| if "lorem ipsum" in combined: |
| errors.append("lorem ipsum found") |
| if spec and spec.project_type == "stripe_checkout": |
| for path in ["src/app/api/checkout/route.ts", "src/app/api/webhooks/stripe/route.ts"]: |
| if path not in files: |
| errors.append(f"missing Stripe route: {path}") |
| if "process.env.stripe_secret_key" not in combined: |
| errors.append("Stripe secret is not server-side env based") |
| if "constructevent" not in combined: |
| errors.append("missing Stripe webhook signature verification") |
| if spec and spec.project_type in {"booking_app", "crm_app", "dashboard", "invoice_app", "estimate_app", "content_calendar", "expense_tracker"}: |
| page = files.get("src/app/page.tsx", "") |
| for path in ["src/lib/csv.ts", "tests/csv.test.ts"]: |
| if path not in files: |
| errors.append(f"missing interactive app support file: {path}") |
| for token in ['"use client"', "localStorage", "Export CSV", "Delete", "Save locally"]: |
| if token not in page: |
| errors.append(f"interactive app page missing token: {token}") |
| if "tocsv" not in combined: |
| errors.append("interactive app missing CSV export utility") |
| if spec and spec.project_type == "cloudflare_worker": |
| for path in ["wrangler.toml", "src/index.ts", "tests/worker.test.ts"]: |
| if path not in files: |
| errors.append(f"missing Worker file: {path}") |
| worker = files.get("src/index.ts", "") |
| wrangler = files.get("wrangler.toml", "") |
| if "export default" not in worker: |
| errors.append("missing Worker fetch export") |
| if "access-control-allow-origin" not in combined: |
| errors.append("missing CORS handling") |
| if "/health" not in combined or "/leads" not in combined: |
| errors.append("missing health/leads routes") |
| if worker_has(spec, "telegram") and ("/telegram/webhook" not in worker or "TELEGRAM_BOT_TOKEN" not in worker): |
| errors.append("missing Telegram webhook route or env") |
| if worker_has(spec, "r2", "upload", "file") and ("/files" not in worker or "FILES_BUCKET" not in worker or "[[r2_buckets]]" not in wrangler): |
| errors.append("missing R2 upload route or binding") |
| if worker_has(spec, "d1", "database", "persist") and ("env.DB" not in worker or "[[d1_databases]]" not in wrangler): |
| errors.append("missing D1 persistence route logic or binding") |
| if worker_has(spec, "search", "perplexity") and ("/search" not in worker or "PERPLEXITY_API_KEY" not in worker): |
| errors.append("missing server-side search proxy route or env") |
| if worker_has(spec, "auth", "license", "rate limit", "api key"): |
| auth_required = ["API_TOKEN_HASH", "requireBearer", "crypto.subtle.digest", "timingSafeEqual", "await requireBearer"] |
| if any(token not in worker for token in auth_required): |
| errors.append("missing verified bearer auth guard") |
| return errors |
|
|
|
|
| def write_project(root: Path, files: dict[str, str]) -> None: |
| root.mkdir(parents=True, exist_ok=True) |
| for relative, content in files.items(): |
| path = root / relative |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(content, encoding="utf-8") |
|
|
|
|
| def render_from_prompt(prompt: str) -> tuple[CodeProjectSpec, dict[str, str], list[str]]: |
| spec, files = render_files(spec_from_prompt(prompt), prompt) |
| return spec, files, validate_files(files, spec) |
|
|
|
|
| def spec_to_json(spec: CodeProjectSpec) -> str: |
| return json.dumps(spec.__dict__, indent=2, ensure_ascii=False) |
|
|
