npm - create-pyric - Versions diffs - 0.1.0-alpha.9 - Mend

create-pyric 0.1.0-alpha.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/dist/templates.js ADDED Viewed

@@ -0,0 +1,611 @@
+/**
+ * Scaffold templates for `pyric init` (engine in `./init.js`).
+ *
+ * `web` (the default) scaffolds a **Vite app** wired to the `@pyric/cli/vite`
+ * plugin: `vite dev` runs the app's CANONICAL `firebase/*` imports against the
+ * in-process sandbox; `vite build` ships the real `firebase` package. One
+ * toolchain, no graduation cliff — the sandbox↔Firebase swap is environmental
+ * (dev vs build), never a code edit (the design rationale section 9).
+ *
+ * `static` is the serve-era scaffold (no bundler): a static app `pyric dev`
+ * runs against the in-page sandbox via a runtime import map. For pre-built /
+ * retrofit apps, or anyone who wants zero build step.
+ *
+ * `node` is the script-style scaffold (backend fixtures, agent loops). Its
+ * canonical imports are swapped by the dev command and remain Firebase under
+ * the production command.
+ */
+// ─── web template ─────────────────────────────────────────────────────
+const WEB_INDEX_HTML = (name) => `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${name}</title>
+    <style>
+      body { font: 16px/1.5 system-ui, sans-serif; max-width: 640px; margin: 3rem auto; padding: 0 1rem; }
+      button { padding: 0.4rem 0.9rem; cursor: pointer; }
+      form { display: flex; gap: 0.5rem; margin: 1rem 0; }
+      input { flex: 1; padding: 0.4rem 0.6rem; }
+      ul { padding-left: 1.2rem; }
+      .status { color: #666; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${name}</h1>
+      <p class="status" id="auth-status">Signed out</p>
+      <button id="sign-in">Sign in with Google</button>
+      <button id="sign-out" hidden>Sign out</button>
+      <form id="add-post" hidden>
+        <input id="post-title" placeholder="Post title" required />
+        <button type="submit">Add post</button>
+      </form>
+      <ul id="posts"></ul>
+    </main>
+    <script type="module" src="/app.js"></script>
+  </body>
+</html>
+`;
+const WEB_APP_JS = `// Canonical firebase/* imports. Under \`pyric dev\` they are served by the
+// in-page pyric sandbox (the config below is ignored); under any standard
+// bundler/pipeline the same imports resolve to the real \`firebase\` package.
+// Graduation changes where you run this code, never the code itself.
+import { initializeApp } from 'firebase/app';
+import {
+  getAuth,
+  onAuthStateChanged,
+  signInWithPopup,
+  signOut,
+  GoogleAuthProvider,
+} from 'firebase/auth';
+import {
+  getFirestore,
+  collection,
+  onSnapshot,
+  addDoc,
+  serverTimestamp,
+} from 'firebase/firestore';
+const app = initializeApp({
+  // Graduation: your real web-app config from the Firebase console
+  // (see .env.example). Unused while developing under \`pyric dev\`.
+  apiKey: 'demo',
+  authDomain: 'demo.firebaseapp.com',
+  projectId: 'demo',
+});
+const auth = getAuth(app);
+const db = getFirestore(app);
+const els = {
+  status: document.getElementById('auth-status'),
+  signIn: document.getElementById('sign-in'),
+  signOut: document.getElementById('sign-out'),
+  form: document.getElementById('add-post'),
+  title: document.getElementById('post-title'),
+  posts: document.getElementById('posts'),
+};
+els.signIn.addEventListener('click', () => signInWithPopup(auth, new GoogleAuthProvider()));
+els.signOut.addEventListener('click', () => signOut(auth));
+onAuthStateChanged(auth, (user) => {
+  els.status.textContent = user
+    ? 'Signed in as ' + (user.displayName ?? user.email)
+    : 'Signed out';
+  els.signIn.hidden = !!user;
+  els.signOut.hidden = !user;
+  els.form.hidden = !user;
+});
+els.form.addEventListener('submit', async (e) => {
+  e.preventDefault();
+  // The owner-based rules require uid == request.auth.uid on create.
+  await addDoc(collection(db, 'posts'), {
+    title: els.title.value.trim(),
+    uid: auth.currentUser.uid,
+    createdAt: serverTimestamp(),
+  });
+  els.title.value = '';
+});
+onSnapshot(collection(db, 'posts'), (snap) => {
+  els.posts.replaceChildren(
+    ...snap.docs.map((d) => {
+      const li = document.createElement('li');
+      li.textContent = d.data().title;
+      return li;
+    }),
+  );
+});
+`;
+const WEB_RULES = `rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    // Owner-based from line 1 — \`pyric dev\` hot-reloads this file and
+    // ships a sign-in helper, so safe rules are cheap to iterate. These
+    // deploy as-is.
+    match /posts/{postId} {
+      allow read: if true;
+      allow create: if request.auth != null
+                    && request.resource.data.uid == request.auth.uid;
+      allow update, delete: if request.auth != null
+                            && resource.data.uid == request.auth.uid;
+    }
+    // Default deny — opt in per collection.
+    match /{document=**} {
+      allow read, write: if false;
+    }
+  }
+}
+`;
+const WEB_FIREBASE_JSON = `{
+  "firestore": {
+    "rules": "firestore.rules",
+    "indexes": "firestore.indexes.json"
+  },
+  "hosting": {
+    "public": "public",
+    "rewrites": [{ "source": "**", "destination": "/index.html" }]
+  }
+}
+`;
+const WEB_SEED_JSON = `{
+  "posts/welcome": { "title": "Welcome to pyric", "uid": "seed" },
+  "posts/sandboxed": { "title": "This page runs on the in-page sandbox", "uid": "seed" }
+}
+`;
+const WEB_ENV_EXAMPLE = `# Graduation config — your real Firebase web app (console → project settings).
+# Unused under \`pyric dev\`; wire it into public/app.js (or a bundler env)
+# when you deploy against the real backend.
+FIREBASE_API_KEY=
+FIREBASE_AUTH_DOMAIN=
+FIREBASE_PROJECT_ID=
+FIREBASE_STORAGE_BUCKET=
+FIREBASE_MESSAGING_SENDER_ID=
+FIREBASE_APP_ID=
+`;
+const webReadme = (name) => `# ${name}
+A Firebase web app. In development it runs entirely on pyric's in-page
+sandbox — no Firebase project, credentials, or emulators.
+- **Develop:** \`bun install && bun run dev\` — serves \`public/\` with the
+  sandbox standing in for Firebase: seeded data, rules enforced + hot-reloaded,
+  popup sign-in via the helper dialog.
+- **Agent:** \`bun run dev:agent\` — same, plus the MCP bridge on the dev-server
+  origin (\`/__pyric/mcp\`).
+- **Persist (optional):** \`pyric dev --persist --seed seed.json\` — data and
+  test users survive reloads and restarts in \`.pyric/state/state.json\`
+  (plain JSON; gitignored). Promote lived state to a committable fixture
+  with \`pyric snapshot\`, then re-serve it: \`pyric dev --seed pyric-state.json\`.
+- **Graduate:** fill \`.env\` from the Firebase console and point the config in
+  \`public/app.js\` at it, then run \`npx firebase-tools deploy\`. Bare
+  \`firebase/*\` imports need a bundler
+  (e.g. \`vite build\`) or an import map in production — \`pyric dev\`
+  provides the map in dev.
+The app code uses canonical \`firebase/*\` imports everywhere. Switching
+between sandbox and real Firebase is about **where you run it**, never what
+you wrote.
+`;
+const GITIGNORE = `node_modules/
+dist/
+.env
+.firebaserc
+.pyric/
+*.log
+`;
+const FIRESTORE_INDEXES = `{
+  "indexes": [],
+  "fieldOverrides": []
+}
+`;
+// ─── node template (init v1 scaffold, carried over) ───────────────────
+const NODE_APP_TS = `// Canonical Firebase imports stay unchanged between sandbox and production.
+// \`bun run dev\` activates @pyric/cli/register; \`bun start\` loads Firebase.
+import { initializeApp } from 'firebase/app';
+import { getFirestore, collection, getDocs } from 'firebase/firestore';
+import { seed } from './seed.ts';
+const app = initializeApp({
+  apiKey: process.env.FIREBASE_API_KEY ?? 'pyric-local',
+  authDomain: process.env.FIREBASE_AUTH_DOMAIN,
+  projectId: process.env.FIREBASE_PROJECT_ID ?? 'pyric-local',
+  appId: process.env.FIREBASE_APP_ID ?? 'pyric-local',
+});
+const db = getFirestore(app);
+if (process.env.PYRIC_SANDBOX) {
+  await seed(db);
+}
+const snap = await getDocs(collection(db, 'posts'));
+console.log(\`\${snap.size} posts:\`);
+snap.forEach((doc) => console.log(\`  \${doc.id}:\`, doc.data()));
+// Production: fill .env, deploy firestore.rules, then \`bun start\`.
+`;
+const NODE_SEED_TS = `import { collection, addDoc, type Firestore } from 'firebase/firestore';
+export async function seed(db: Firestore): Promise<void> {
+  await addDoc(collection(db, 'posts'), {
+    title: 'Hello, Pyric',
+    author: 'sandbox',
+    createdAt: new Date(),
+  });
+  await addDoc(collection(db, 'posts'), {
+    title: 'Local-first by default',
+    author: 'sandbox',
+    createdAt: new Date(),
+  });
+}
+`;
+const NODE_ENV_EXAMPLE = `# Production Firebase config (Firebase console -> project settings).
+# Sandbox development uses the fallback values in src/app.ts.
+FIREBASE_API_KEY=
+FIREBASE_AUTH_DOMAIN=
+FIREBASE_PROJECT_ID=
+FIREBASE_APP_ID=
+`;
+const NODE_RULES = `rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    // Local-first defaults: open in the sandbox so the quickstart
+    // works out of the box. **Tighten these before deploying with firebase-tools**
+    // — anonymous read+write is not what you want
+    // in the wild.
+    match /posts/{postId} {
+      allow read: if true;
+      allow write: if true;
+    }
+    // Default deny for everything else — opt in per collection.
+    match /{document=**} {
+      allow read, write: if false;
+    }
+  }
+}
+`;
+const NODE_FIREBASE_JSON = `{
+  "firestore": {
+    "rules": "firestore.rules",
+    "indexes": "firestore.indexes.json"
+  }
+}
+`;
+const nodeReadme = (name) => `# ${name}
+A Firebase app whose canonical imports run against Pyric in development and
+real Firebase in production. No application-code switch is required.
+## Quick start
+\`\`\`bash
+bun install
+bun run dev        # Pyric sandbox through the Node package swap
+bun start          # production: real Firebase
+\`\`\`
+## Use with an MCP-connected agent (Claude Code)
+Install the pyric Claude Code plugin once. It auto-connects through a bundled
+stdio proxy that discovers the running bridge from \`.pyric/serve.json\` and probes
+both IPv4 + IPv6, so there is NO \`claude mcp add\` step and no hand-written URL (a
+static \`127.0.0.1\` URL hits the loopback-family trap). Just start the bridge:
+\`\`\`bash
+pyric bridge       # default port 5174
+\`\`\`
+and the agent's pyric tools attach automatically.
+## Graduating to a real Firebase project
+Graduation is a command change, not a code edit:
+1. Create a project at https://console.firebase.google.com and fill \`.env\`
+   (see \`.env.example\`).
+2. **Tighten \`firestore.rules\`** — the scaffolded rules are open for
+   sandbox convenience.
+3. Deploy them with the Firebase CLI: add a \`.firebaserc\`
+   (\`{ "projects": { "default": "your-project-id" } }\`), then run
+   \`npx firebase-tools deploy --only firestore:rules\`.
+4. Run the same canonical-import code against the real backend: \`bun start\`.
+`;
+// ─── web template (Vite + @pyric/cli/vite) ───────────────────────────
+const VITE_INDEX_HTML = (name) => `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${name}</title>
+    <style>
+      body { font: 16px/1.5 system-ui, sans-serif; max-width: 640px; margin: 3rem auto; padding: 0 1rem; }
+      button { padding: 0.4rem 0.9rem; cursor: pointer; }
+      form { display: flex; gap: 0.5rem; margin: 1rem 0; }
+      input { flex: 1; padding: 0.4rem 0.6rem; }
+      ul { padding-left: 1.2rem; }
+      .status { color: #666; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${name}</h1>
+      <p class="status" id="auth-status">Signed out</p>
+      <button id="sign-in">Sign in with Google</button>
+      <button id="sign-out" hidden>Sign out</button>
+      <form id="add-post" hidden>
+        <input id="post-title" placeholder="Post title" required />
+        <button type="submit">Add post</button>
+      </form>
+      <ul id="posts"></ul>
+    </main>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+`;
+const VITE_MAIN_TS = `// Canonical firebase/* imports — UNCHANGED between dev and prod.
+// In \`vite dev\` the \`@pyric/cli/vite\` plugin swaps these to an in-process
+// sandbox (the config below is accepted but ignored). \`vite build\` ships the
+// real \`firebase\` package and uses the SAME config. Graduation is a build, not
+// a code edit.
+import { initializeApp } from 'firebase/app';
+import {
+  getAuth,
+  onAuthStateChanged,
+  signInWithPopup,
+  signOut,
+  GoogleAuthProvider,
+} from 'firebase/auth';
+import {
+  getFirestore,
+  collection,
+  onSnapshot,
+  addDoc,
+  serverTimestamp,
+} from 'firebase/firestore';
+const app = initializeApp({
+  // Filled from .env (see .env.example) at \`vite build\` time for production.
+  // Ignored in \`vite dev\` — the pyric sandbox stands in for Firebase.
+  apiKey: import.meta.env.VITE_FIREBASE_API_KEY ?? 'demo',
+  authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN ?? 'demo.firebaseapp.com',
+  projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID ?? 'demo',
+});
+const auth = getAuth(app);
+const db = getFirestore(app);
+const $ = <T extends HTMLElement>(id: string): T => document.getElementById(id) as T;
+const els = {
+  status: $('auth-status'),
+  signIn: $<HTMLButtonElement>('sign-in'),
+  signOut: $<HTMLButtonElement>('sign-out'),
+  form: $<HTMLFormElement>('add-post'),
+  title: $<HTMLInputElement>('post-title'),
+  posts: $('posts'),
+};
+els.signIn.addEventListener('click', () => signInWithPopup(auth, new GoogleAuthProvider()));
+els.signOut.addEventListener('click', () => signOut(auth));
+onAuthStateChanged(auth, (user) => {
+  els.status.textContent = user
+    ? 'Signed in as ' + (user.displayName ?? user.email)
+    : 'Signed out';
+  els.signIn.hidden = !!user;
+  els.signOut.hidden = !user;
+});
+els.form.addEventListener('submit', async (e) => {
+  e.preventDefault();
+  // The form stays visible while signed out ON PURPOSE: submitting then
+  // ATTEMPTS the write, the owner-based rules deny it (create requires
+  // uid == request.auth.uid), and the denial shows up in Pyric Studio's
+  // Traffic tab — the rules-teaching loop this demo exists for.
+  const user = auth.currentUser;
+  try {
+    await addDoc(collection(db, 'posts'), {
+      title: els.title.value.trim(),
+      uid: user?.uid ?? 'anonymous',
+      createdAt: serverTimestamp(),
+    });
+    els.title.value = '';
+  } catch (err) {
+    els.status.textContent = user
+      ? \`Write failed: \${(err as { code?: string }).code ?? String(err)}\`
+      : 'Denied by rules (signed out) — see the Traffic tab in Pyric Studio.';
+  }
+});
+onSnapshot(collection(db, 'posts'), (snap) => {
+  els.posts.replaceChildren(
+    ...snap.docs.map((d) => {
+      const li = document.createElement('li');
+      li.textContent = (d.data() as { title?: string }).title ?? '';
+      return li;
+    }),
+  );
+});
+`;
+const VITE_CONFIG = `import { defineConfig } from 'vite';
+import { pyricSandbox } from '@pyric/cli/vite';
+// Under \`vite dev\` pyricSandbox() swaps firebase/* to the in-process pyric
+// sandbox and deploys + hot-reloads firestore.rules — no Firebase project,
+// credentials, or emulators. \`vite build\` (mode production) ships the real
+// firebase package; the swap never reaches the deployed artifact. For a
+// self-contained sandbox preview you can serve under \`pyric dev\`, build with a
+// non-production mode: \`vite build --mode development\` (see the \`build:sandbox\`
+// script). That output is marked and can never be deployed.
+export default defineConfig({
+  plugins: [pyricSandbox()],
+});
+`;
+const VITE_TSCONFIG = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["vite/client"]
+  },
+  "include": ["src"]
+}
+`;
+// Owner-based rules for the Vite web template. Same shape as the static
+// template's WEB_RULES, but the comment reflects the plugin (not pyric dev) —
+// keep this in lockstep with examples/vite-sandbox-app/firestore.rules.
+const VITE_RULES = `rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    // Owner-based from line 1 — the Vite plugin deploys + hot-reloads this file
+    // into the sandbox, so safe rules are cheap to iterate. These deploy as-is.
+    match /posts/{postId} {
+      allow read: if true;
+      allow create: if request.auth != null
+                    && request.resource.data.uid == request.auth.uid;
+      allow update, delete: if request.auth != null
+                            && resource.data.uid == request.auth.uid;
+    }
+    // Default deny — opt in per collection.
+    match /{document=**} {
+      allow read, write: if false;
+    }
+  }
+}
+`;
+const VITE_ENV_DTS = `/// <reference types="vite/client" />
+`;
+const VITE_FIREBASE_JSON = `{
+  "firestore": {
+    "rules": "firestore.rules",
+    "indexes": "firestore.indexes.json"
+  },
+  "hosting": {
+    "public": "dist",
+    "rewrites": [{ "source": "**", "destination": "/index.html" }]
+  }
+}
+`;
+const VITE_ENV_EXAMPLE = `# Your real Firebase web-app config (Firebase console -> project settings).
+# UNUSED in \`vite dev\` (the pyric sandbox stands in); USED by \`vite build\` for
+# production. Vite only exposes \`VITE_\`-prefixed vars to client code.
+VITE_FIREBASE_API_KEY=
+VITE_FIREBASE_AUTH_DOMAIN=
+VITE_FIREBASE_PROJECT_ID=
+VITE_FIREBASE_STORAGE_BUCKET=
+VITE_FIREBASE_MESSAGING_SENDER_ID=
+VITE_FIREBASE_APP_ID=
+`;
+const viteReadme = (name) => `# ${name}
+A Firebase web app built with Vite. In development it runs entirely on pyric's
+in-process sandbox — no Firebase project, credentials, or emulators.
+- **Develop:** \`bun install && bun run dev\` — \`vite dev\` with the
+  \`@pyric/cli/vite\` plugin swapping \`firebase/*\` to the sandbox: seeded data,
+  your \`firestore.rules\` deployed + hot-reloaded, popup sign-in.
+- **Build for production:** \`bun run build\` — \`vite build\` ships the real
+  \`firebase\` package. Fill \`.env\` from the Firebase console (see
+  \`.env.example\`); the SAME config you wrote runs against real Firebase. There
+  is no separate "graduation" step — dev and prod are one toolchain.
+- **Deploy:** \`npx firebase-tools deploy\` after the production build
+  (\`hosting.public\` is \`dist/\`, Vite's build output).
+> Your app code uses canonical \`firebase/*\` imports everywhere. Switching
+> between the sandbox and real Firebase is \`vite dev\` vs \`vite build\`, never
+> what you wrote.
+The plugin is dev-only: SharedWorker multi-tab sync, \`--persist\`, capture, and
+the MCP bridge (all available today under \`pyric dev\`) arrive in the plugin in
+later releases. For a pre-built / no-build app, use \`pyric init --template static\`
++ \`pyric dev\`.
+`;
+// ─── the registry ─────────────────────────────────────────────────────
+export const TEMPLATES = {
+    // web (default) — a Vite app on the @pyric/cli/vite plugin. `vite dev` runs
+    // on the sandbox; `vite build` ships real firebase. One toolchain.
+    web: {
+        scripts: {
+            dev: 'vite',
+            build: 'vite build',
+            'build:sandbox': 'vite build --mode development',
+            preview: 'vite preview',
+        },
+        // The real firebase package ships day one so the production `vite build`
+        // resolves the same canonical imports against it — no code edit at graduation.
+        dependencies: { firebase: '^12.12.0' },
+        devDependencies: { '@pyric/cli': '*', vite: '^6.0.0', typescript: '^5.7.0' },
+        dirs: ['src'],
+        files: (name) => [
+            { name: 'index.html', content: VITE_INDEX_HTML(name) },
+            { name: 'vite.config.ts', content: VITE_CONFIG },
+            { name: 'tsconfig.json', content: VITE_TSCONFIG },
+            { name: 'src/main.ts', content: VITE_MAIN_TS },
+            { name: 'src/vite-env.d.ts', content: VITE_ENV_DTS },
+            { name: 'firestore.rules', content: VITE_RULES },
+            { name: 'firebase.json', content: VITE_FIREBASE_JSON },
+            { name: 'firestore.indexes.json', content: FIRESTORE_INDEXES },
+            { name: '.env.example', content: VITE_ENV_EXAMPLE },
+            { name: 'README.md', content: viteReadme(name) },
+            { name: '.gitignore', content: GITIGNORE },
+        ],
+        nextSteps: [
+            'bun install',
+            'bun run dev    # vite dev on the pyric sandbox',
+            'bun run build  # production build against real Firebase',
+        ],
+    },
+    node: {
+        scripts: {
+            start: 'node --env-file-if-exists=.env --experimental-strip-types src/app.ts',
+            dev: 'pyric dev --no-open -- node --env-file-if-exists=.env --experimental-strip-types src/app.ts',
+            bridge: 'pyric bridge',
+        },
+        dependencies: { firebase: '^12.12.0' },
+        devDependencies: { '@pyric/cli': '*', '@types/node': '^22.0.0', typescript: '^5.7.0' },
+        dirs: ['src'],
+        files: (name) => [
+            { name: 'src/app.ts', content: NODE_APP_TS },
+            { name: '.env.example', content: NODE_ENV_EXAMPLE },
+            { name: 'src/seed.ts', content: NODE_SEED_TS },
+            { name: 'firestore.rules', content: NODE_RULES },
+            { name: 'firebase.json', content: NODE_FIREBASE_JSON },
+            { name: 'firestore.indexes.json', content: FIRESTORE_INDEXES },
+            { name: 'README.md', content: nodeReadme(name) },
+            { name: '.gitignore', content: GITIGNORE },
+        ],
+        nextSteps: ['bun install', 'bun run dev', 'bun start  # production: real Firebase'],
+    },
+    // static — the serve-era, no-bundler scaffold: a static app `pyric dev`
+    // runs against the in-page sandbox via a runtime import map. For pre-built /
+    // retrofit apps, or anyone who wants zero build step.
+    static: {
+        scripts: {
+            dev: 'pyric dev --seed seed.json',
+            'dev:agent': 'pyric dev --bridge --seed seed.json',
+        },
+        dependencies: { firebase: '^12.12.0' },
+        devDependencies: { '@pyric/cli': '*' },
+        dirs: ['public'],
+        files: (name) => [
+            { name: 'public/index.html', content: WEB_INDEX_HTML(name) },
+            { name: 'public/app.js', content: WEB_APP_JS },
+            { name: 'firestore.rules', content: WEB_RULES },
+            { name: 'firebase.json', content: WEB_FIREBASE_JSON },
+            { name: 'firestore.indexes.json', content: FIRESTORE_INDEXES },
+            { name: 'seed.json', content: WEB_SEED_JSON },
+            { name: '.env.example', content: WEB_ENV_EXAMPLE },
+            { name: 'README.md', content: webReadme(name) },
+            { name: '.gitignore', content: GITIGNORE },
+        ],
+        nextSteps: ['bun install', 'bun run dev', 'bun run dev:agent  # agents: MCP at /__pyric/mcp'],
+    },
+};
+//# sourceMappingURL=templates.js.map

package/dist/templates.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"templates.js","sourceRoot":"","sources":["../src/templates.ts"],"names":[],"mappings":"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"}

package/package.json ADDED Viewed

@@ -0,0 +1,45 @@
+{
+  "name": "create-pyric",
+  "version": "0.1.0-alpha.9",
+  "license": "Apache-2.0",
+  "homepage": "https://pyric.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davideast/pyric.git",
+    "directory": "packages/create-pyric"
+  },
+  "bugs": {
+    "url": "https://github.com/davideast/pyric/issues"
+  },
+  "description": "Scaffold a Pyric + Vite app — `npm create pyric`.",
+  "type": "module",
+  "bin": {
+    "create-pyric": "./dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && chmod +x dist/bin.js",
+    "test": "bun test",
+    "typecheck": "bun x tsc -p tsconfig.json --noEmit"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=22.15"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}