clawfire 0.1.0

package/dist/schema-BJsictSV.d.cts

@@ -0,0 +1,172 @@
+import { ZodType, z, ZodObject, ZodRawShape } from 'zod';
+
+/**
+ * Clawfire Schema & Contract System
+ *
+ * 모든 API는 input/output schema + meta + handler로 구성된 "계약(Contract)"으로 정의됩니다.
+ * Zod를 사용하여 타입 안전성과 런타임 검증을 동시에 보장합니다.
+ */
+
+/** 인증 컨텍스트 */
+interface AuthContext {
+    uid: string;
+    email?: string;
+    emailVerified?: boolean;
+    role?: string;
+    customClaims?: Record<string, unknown>;
+    token?: string;
+}
+/** API 핸들러에 전달되는 컨텍스트 */
+interface HandlerContext {
+    auth: AuthContext | null;
+    /** 재인증 여부 (민감 작업용) */
+    reauthenticated?: boolean;
+    /** 원본 요청 헤더 */
+    headers?: Record<string, string>;
+    /** 요청 IP */
+    ip?: string;
+}
+/** 권한 수준 */
+type AuthLevel = "public" | "authenticated" | "role" | "reauth";
+/** API 메타데이터 */
+interface APIMeta {
+    /** API 설명 (AI/Playground용) */
+    description: string;
+    /** 태그 (그룹화용) */
+    tags?: string[];
+    /** 인증 요구 수준 */
+    auth?: AuthLevel;
+    /** 필요 역할 (auth가 'role'일 때) */
+    roles?: string[];
+    /** 재인증 필요 여부 */
+    reauth?: boolean;
+    /** Rate limit (초당 요청 수) */
+    rateLimit?: number;
+    /** 비활성화 여부 */
+    deprecated?: boolean;
+    /** 예시 입력값 */
+    exampleInput?: unknown;
+    /** 예시 출력값 */
+    exampleOutput?: unknown;
+}
+/** API 계약 정의 */
+interface APIContract<TInput extends ZodType = ZodType, TOutput extends ZodType = ZodType> {
+    /** 입력 스키마 */
+    input: TInput;
+    /** 출력 스키마 */
+    output: TOutput;
+    /** 메타데이터 */
+    meta: APIMeta;
+    /** 핸들러 함수 */
+    handler: (input: z.infer<TInput>, ctx: HandlerContext) => Promise<z.infer<TOutput>>;
+}
+/** 모델 필드 정의 */
+interface ModelField {
+    type: "string" | "number" | "boolean" | "timestamp" | "array" | "map" | "reference" | "geopoint";
+    required?: boolean;
+    description?: string;
+    default?: unknown;
+    /** 배열 아이템 타입 */
+    items?: ModelField;
+    /** 맵 값 타입 */
+    values?: ModelField;
+    /** 참조 대상 컬렉션 */
+    ref?: string;
+    /** enum 값 리스트 */
+    enum?: string[];
+}
+/** 모델 정의 */
+interface ModelDefinition {
+    /** 컬렉션 이름 */
+    collection: string;
+    /** 필드 정의 */
+    fields: Record<string, ModelField>;
+    /** 서브컬렉션 */
+    subcollections?: Record<string, ModelDefinition>;
+    /** 인덱스 */
+    indexes?: ModelIndex[];
+    /** 보안 규칙 */
+    rules?: ModelRules;
+    /** 타임스탬프 자동 생성 */
+    timestamps?: boolean;
+    /** 소프트 삭제 */
+    softDelete?: boolean;
+}
+/** Firestore 인덱스 */
+interface ModelIndex {
+    fields: Array<{
+        field: string;
+        order?: "asc" | "desc";
+    }>;
+}
+/** 모델 보안 규칙 */
+interface ModelRules {
+    read?: AuthLevel;
+    create?: AuthLevel;
+    update?: AuthLevel;
+    delete?: AuthLevel;
+    readRoles?: string[];
+    createRoles?: string[];
+    updateRoles?: string[];
+    deleteRoles?: string[];
+    /** 소유자만 읽기/쓰기 가능 필드 */
+    ownerField?: string;
+}
+/**
+ * API 계약 정의
+ *
+ * @example
+ * ```ts
+ * export default defineAPI({
+ *   input: z.object({ name: z.string() }),
+ *   output: z.object({ id: z.string(), name: z.string() }),
+ *   meta: { description: "상품 생성", auth: "authenticated" },
+ *   handler: async (input, ctx) => {
+ *     const id = await db.create("products", input);
+ *     return { id, ...input };
+ *   }
+ * });
+ * ```
+ */
+declare function defineAPI<TInput extends ZodType, TOutput extends ZodType>(contract: APIContract<TInput, TOutput>): APIContract<TInput, TOutput>;
+/**
+ * 모델(Firestore 컬렉션) 정의
+ *
+ * @example
+ * ```ts
+ * export const Product = defineModel({
+ *   collection: "products",
+ *   fields: {
+ *     name: { type: "string", required: true },
+ *     price: { type: "number", required: true },
+ *     tags: { type: "array", items: { type: "string" } },
+ *   },
+ *   timestamps: true,
+ *   rules: { read: "public", create: "authenticated" }
+ * });
+ * ```
+ */
+declare function defineModel(definition: ModelDefinition): ModelDefinition;
+/** Zod 스키마에서 JSON Schema 생성 (Playground/문서용) */
+declare function zodToJsonSchema(schema: ZodType): Record<string, unknown>;
+/** 모델 정의에서 Zod 스키마 자동 생성 */
+declare function modelToZodSchema(model: ModelDefinition): ZodObject<ZodRawShape>;
+/** API 매니페스트 항목 */
+interface ManifestEntry {
+    path: string;
+    method: "POST";
+    meta: APIMeta;
+    inputSchema: Record<string, unknown>;
+    outputSchema: Record<string, unknown>;
+}
+/** 전체 매니페스트 */
+interface Manifest {
+    version: string;
+    generatedAt: string;
+    apis: ManifestEntry[];
+    models: Record<string, ModelDefinition>;
+}
+/** 계약에서 매니페스트 항목 생성 */
+declare function contractToManifest(path: string, contract: APIContract): ManifestEntry;
+
+export { type APIContract as A, type HandlerContext as H, type Manifest as M, type APIMeta as a, type AuthContext as b, type AuthLevel as c, type ManifestEntry as d, type ModelDefinition as e, type ModelField as f, defineAPI as g, defineModel as h, type ModelIndex as i, type ModelRules as j, contractToManifest as k, modelToZodSchema as m, zodToJsonSchema as z };

package/dist/schema-BJsictSV.d.ts

@@ -0,0 +1,172 @@
+import { ZodType, z, ZodObject, ZodRawShape } from 'zod';
+
+/**
+ * Clawfire Schema & Contract System
+ *
+ * 모든 API는 input/output schema + meta + handler로 구성된 "계약(Contract)"으로 정의됩니다.
+ * Zod를 사용하여 타입 안전성과 런타임 검증을 동시에 보장합니다.
+ */
+
+/** 인증 컨텍스트 */
+interface AuthContext {
+    uid: string;
+    email?: string;
+    emailVerified?: boolean;
+    role?: string;
+    customClaims?: Record<string, unknown>;
+    token?: string;
+}
+/** API 핸들러에 전달되는 컨텍스트 */
+interface HandlerContext {
+    auth: AuthContext | null;
+    /** 재인증 여부 (민감 작업용) */
+    reauthenticated?: boolean;
+    /** 원본 요청 헤더 */
+    headers?: Record<string, string>;
+    /** 요청 IP */
+    ip?: string;
+}
+/** 권한 수준 */
+type AuthLevel = "public" | "authenticated" | "role" | "reauth";
+/** API 메타데이터 */
+interface APIMeta {
+    /** API 설명 (AI/Playground용) */
+    description: string;
+    /** 태그 (그룹화용) */
+    tags?: string[];
+    /** 인증 요구 수준 */
+    auth?: AuthLevel;
+    /** 필요 역할 (auth가 'role'일 때) */
+    roles?: string[];
+    /** 재인증 필요 여부 */
+    reauth?: boolean;
+    /** Rate limit (초당 요청 수) */
+    rateLimit?: number;
+    /** 비활성화 여부 */
+    deprecated?: boolean;
+    /** 예시 입력값 */
+    exampleInput?: unknown;
+    /** 예시 출력값 */
+    exampleOutput?: unknown;
+}
+/** API 계약 정의 */
+interface APIContract<TInput extends ZodType = ZodType, TOutput extends ZodType = ZodType> {
+    /** 입력 스키마 */
+    input: TInput;
+    /** 출력 스키마 */
+    output: TOutput;
+    /** 메타데이터 */
+    meta: APIMeta;
+    /** 핸들러 함수 */
+    handler: (input: z.infer<TInput>, ctx: HandlerContext) => Promise<z.infer<TOutput>>;
+}
+/** 모델 필드 정의 */
+interface ModelField {
+    type: "string" | "number" | "boolean" | "timestamp" | "array" | "map" | "reference" | "geopoint";
+    required?: boolean;
+    description?: string;
+    default?: unknown;
+    /** 배열 아이템 타입 */
+    items?: ModelField;
+    /** 맵 값 타입 */
+    values?: ModelField;
+    /** 참조 대상 컬렉션 */
+    ref?: string;
+    /** enum 값 리스트 */
+    enum?: string[];
+}
+/** 모델 정의 */
+interface ModelDefinition {
+    /** 컬렉션 이름 */
+    collection: string;
+    /** 필드 정의 */
+    fields: Record<string, ModelField>;
+    /** 서브컬렉션 */
+    subcollections?: Record<string, ModelDefinition>;
+    /** 인덱스 */
+    indexes?: ModelIndex[];
+    /** 보안 규칙 */
+    rules?: ModelRules;
+    /** 타임스탬프 자동 생성 */
+    timestamps?: boolean;
+    /** 소프트 삭제 */
+    softDelete?: boolean;
+}
+/** Firestore 인덱스 */
+interface ModelIndex {
+    fields: Array<{
+        field: string;
+        order?: "asc" | "desc";
+    }>;
+}
+/** 모델 보안 규칙 */
+interface ModelRules {
+    read?: AuthLevel;
+    create?: AuthLevel;
+    update?: AuthLevel;
+    delete?: AuthLevel;
+    readRoles?: string[];
+    createRoles?: string[];
+    updateRoles?: string[];
+    deleteRoles?: string[];
+    /** 소유자만 읽기/쓰기 가능 필드 */
+    ownerField?: string;
+}
+/**
+ * API 계약 정의
+ *
+ * @example
+ * ```ts
+ * export default defineAPI({
+ *   input: z.object({ name: z.string() }),
+ *   output: z.object({ id: z.string(), name: z.string() }),
+ *   meta: { description: "상품 생성", auth: "authenticated" },
+ *   handler: async (input, ctx) => {
+ *     const id = await db.create("products", input);
+ *     return { id, ...input };
+ *   }
+ * });
+ * ```
+ */
+declare function defineAPI<TInput extends ZodType, TOutput extends ZodType>(contract: APIContract<TInput, TOutput>): APIContract<TInput, TOutput>;
+/**
+ * 모델(Firestore 컬렉션) 정의
+ *
+ * @example
+ * ```ts
+ * export const Product = defineModel({
+ *   collection: "products",
+ *   fields: {
+ *     name: { type: "string", required: true },
+ *     price: { type: "number", required: true },
+ *     tags: { type: "array", items: { type: "string" } },
+ *   },
+ *   timestamps: true,
+ *   rules: { read: "public", create: "authenticated" }
+ * });
+ * ```
+ */
+declare function defineModel(definition: ModelDefinition): ModelDefinition;
+/** Zod 스키마에서 JSON Schema 생성 (Playground/문서용) */
+declare function zodToJsonSchema(schema: ZodType): Record<string, unknown>;
+/** 모델 정의에서 Zod 스키마 자동 생성 */
+declare function modelToZodSchema(model: ModelDefinition): ZodObject<ZodRawShape>;
+/** API 매니페스트 항목 */
+interface ManifestEntry {
+    path: string;
+    method: "POST";
+    meta: APIMeta;
+    inputSchema: Record<string, unknown>;
+    outputSchema: Record<string, unknown>;
+}
+/** 전체 매니페스트 */
+interface Manifest {
+    version: string;
+    generatedAt: string;
+    apis: ManifestEntry[];
+    models: Record<string, ModelDefinition>;
+}
+/** 계약에서 매니페스트 항목 생성 */
+declare function contractToManifest(path: string, contract: APIContract): ManifestEntry;
+
+export { type APIContract as A, type HandlerContext as H, type Manifest as M, type APIMeta as a, type AuthContext as b, type AuthLevel as c, type ManifestEntry as d, type ModelDefinition as e, type ModelField as f, defineAPI as g, defineModel as h, type ModelIndex as i, type ModelRules as j, contractToManifest as k, modelToZodSchema as m, zodToJsonSchema as z };

package/package.json

@@ -0,0 +1,150 @@
+{
+  "name": "clawfire",
+  "version": "0.1.0",
+  "description": "AI-First Firebase app framework — Speak. Build. Deploy.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./client": {
+      "import": {
+        "types": "./dist/client.d.ts",
+        "default": "./dist/client.js"
+      },
+      "require": {
+        "types": "./dist/client.d.cts",
+        "default": "./dist/client.cjs"
+      }
+    },
+    "./functions": {
+      "import": {
+        "types": "./dist/functions.d.ts",
+        "default": "./dist/functions.js"
+      },
+      "require": {
+        "types": "./dist/functions.d.cts",
+        "default": "./dist/functions.cjs"
+      }
+    },
+    "./admin": {
+      "import": {
+        "types": "./dist/admin.d.ts",
+        "default": "./dist/admin.js"
+      },
+      "require": {
+        "types": "./dist/admin.d.cts",
+        "default": "./dist/admin.cjs"
+      }
+    },
+    "./codegen": {
+      "import": {
+        "types": "./dist/codegen.d.ts",
+        "default": "./dist/codegen.js"
+      },
+      "require": {
+        "types": "./dist/codegen.d.cts",
+        "default": "./dist/codegen.cjs"
+      }
+    },
+    "./playground": {
+      "import": {
+        "types": "./dist/playground.d.ts",
+        "default": "./dist/playground.js"
+      },
+      "require": {
+        "types": "./dist/playground.d.cts",
+        "default": "./dist/playground.cjs"
+      }
+    },
+    "./dev": {
+      "import": {
+        "types": "./dist/dev.d.ts",
+        "default": "./dist/dev.js"
+      },
+      "require": {
+        "types": "./dist/dev.d.cts",
+        "default": "./dist/dev.cjs"
+      }
+    }
+  },
+  "bin": {
+    "clawfire": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "release": "source .env && npm publish --access public"
+  },
+  "keywords": [
+    "firebase",
+    "ai",
+    "framework",
+    "no-code",
+    "clawfire",
+    "firestore",
+    "functions",
+    "hosting",
+    "zod",
+    "schema",
+    "api",
+    "contract"
+  ],
+  "author": "nohsangwoo <nsgr12@naver.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nohsangwoo/clawfire.git"
+  },
+  "homepage": "https://github.com/nohsangwoo/clawfire#readme",
+  "bugs": {
+    "url": "https://github.com/nohsangwoo/clawfire/issues"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "zod": "^3.23.0"
+  },
+  "peerDependencies": {
+    "firebase": "^10.0.0 || ^11.0.0",
+    "firebase-admin": "^12.0.0 || ^13.0.0",
+    "firebase-functions": "^5.0.0 || ^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "firebase": {
+      "optional": true
+    },
+    "firebase-admin": {
+      "optional": true
+    },
+    "firebase-functions": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "firebase": "^11.0.0",
+    "firebase-admin": "^13.0.0",
+    "firebase-functions": "^6.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/templates/CLAUDE.md

@@ -0,0 +1,71 @@
+# Clawfire Project
+
+This is a Clawfire project — an AI-First Firebase app framework.
+**"Speak. Build. Deploy."**
+
+## Stack (Fixed — do not change)
+- DB: Firestore
+- Auth: Firebase Auth
+- Hosting: Firebase Hosting
+- Backend: Firebase Functions
+- Schema: Zod
+- Language: TypeScript
+- Framework: Clawfire
+
+## Project Structure
+```
+app/
+  routes/       ← API route handlers (file-based routing)
+  schemas/      ← Model definitions (Firestore collections)
+generated/      ← Auto-generated files (DO NOT EDIT)
+  api-client.ts ← Typed API client
+  manifest.json ← API manifest
+functions/      ← Firebase Functions entry point
+public/         ← Static files for Firebase Hosting
+firebase.json   ← Firebase config
+firestore.rules ← Firestore security rules
+clawfire.config.ts ← Clawfire configuration
+```
+
+## Commands (AI Skills)
+- `/clawfire-init` — Initialize project / connect Firebase
+- `/clawfire-model` — Create/modify data models
+- `/clawfire-api` — Create/modify APIs
+- `/clawfire-auth` — Configure authentication & authorization
+- `/clawfire-deploy` — Deploy to Firebase
+- `/clawfire-diagnose` — Diagnose and fix issues
+
+## Key Patterns
+
+### API Definition
+All APIs use `defineAPI` with input/output Zod schemas:
+```ts
+import { defineAPI, z } from "clawfire";
+export default defineAPI({
+  input: z.object({ ... }),
+  output: z.object({ ... }),
+  meta: { description: "...", auth: "authenticated" },
+  handler: async (input, ctx) => { ... },
+});
+```
+
+### Model Definition
+All Firestore collections use `defineModel`:
+```ts
+import { defineModel } from "clawfire";
+export const Product = defineModel({
+  collection: "products",
+  fields: { ... },
+  timestamps: true,
+  rules: { read: "public", create: "authenticated" },
+});
+```
+
+### All APIs are POST
+Clawfire does not use HTTP methods. Everything is POST with JSON body.
+
+### Auth Levels
+- `public` — No auth required
+- `authenticated` — Login required
+- `role` — Specific role required
+- `reauth` — Recent re-authentication required

package/templates/app/routes/auth/login.ts

@@ -0,0 +1,35 @@
+import { defineAPI, z, Errors } from "clawfire";
+
+export default defineAPI({
+  input: z.object({
+    idToken: z.string().min(1),
+  }),
+  output: z.object({
+    uid: z.string(),
+    email: z.string().optional(),
+    role: z.string().optional(),
+    displayName: z.string().optional(),
+  }),
+  meta: {
+    description: "Verify Firebase ID token and return user info",
+    auth: "public",
+    tags: ["auth"],
+    exampleInput: {
+      idToken: "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
+    },
+  },
+  handler: async (input, ctx) => {
+    // In real implementation, this would use verifyToken from clawfire/functions
+    // and the Firebase Admin Auth instance
+    if (!input.idToken) {
+      throw Errors.unauthorized("No token provided");
+    }
+
+    return {
+      uid: "placeholder-uid",
+      email: "user@example.com",
+      role: "user",
+      displayName: "User",
+    };
+  },
+});

package/templates/app/routes/health.ts

@@ -0,0 +1,20 @@
+import { defineAPI, z } from "clawfire";
+
+export default defineAPI({
+  input: z.object({}),
+  output: z.object({
+    status: z.string(),
+    timestamp: z.string(),
+    version: z.string(),
+  }),
+  meta: {
+    description: "Health check endpoint",
+    auth: "public",
+    tags: ["system"],
+  },
+  handler: async () => ({
+    status: "ok",
+    timestamp: new Date().toISOString(),
+    version: "1.0.0",
+  }),
+});

package/templates/app/schemas/user.ts

@@ -0,0 +1,26 @@
+import { defineModel } from "clawfire";
+
+export const User = defineModel({
+  collection: "users",
+  fields: {
+    email: { type: "string", required: true, description: "User email" },
+    displayName: { type: "string", required: true, description: "Display name" },
+    role: {
+      type: "string",
+      required: true,
+      enum: ["user", "admin", "editor"],
+      description: "User role",
+    },
+    photoURL: { type: "string", description: "Profile photo URL" },
+    bio: { type: "string", description: "User bio" },
+  },
+  timestamps: true,
+  rules: {
+    read: "authenticated",
+    create: "authenticated",
+    update: "authenticated",
+    delete: "role",
+    deleteRoles: ["admin"],
+    ownerField: "uid",
+  },
+});

package/templates/clawfire.config.ts

@@ -0,0 +1,25 @@
+import { configureClawfire } from "clawfire";
+
+export default configureClawfire({
+  firebase: {
+    apiKey: "YOUR_API_KEY",
+    authDomain: "YOUR_PROJECT.firebaseapp.com",
+    projectId: "YOUR_PROJECT_ID",
+    storageBucket: "YOUR_PROJECT.firebasestorage.app",
+    appId: "YOUR_APP_ID",
+  },
+  server: {
+    region: "us-central1",
+    cors: [],
+    rateLimit: 100,
+  },
+  security: {
+    validateInput: true,
+    safeHeaders: true,
+    maskLogs: true,
+  },
+  playground: {
+    enabled: true,
+    path: "/__playground",
+  },
+});