npm - pyric-tools - Versions diffs - 0.1.0-alpha.7 - Mend

pyric-tools 0.1.0-alpha.7

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 (1052) hide show

package/dist/cli/init-templates.js ADDED Viewed

@@ -0,0 +1,638 @@
+/**
+ * Scaffold templates for `pyric init` (engine in `./init.js`).
+ *
+ * `web` (the default) scaffolds a **Vite app** wired to the `pyric-tools/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) carried
+ * over from init v1, with the `PYRIC_TARGET` env swap: the same script runs on
+ * the sandbox (default) or the real project.
+ */
+// ─── 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 \`npx pyric deploy rules\` /
+  \`npx pyric deploy hosting\`. 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 = `/**
+ * Pyric quickstart — \`PYRIC_TARGET\` picks the backend (graduation is an
+ * env change, not a code edit):
+ *   (unset) / sandbox  → in-process sandbox; no Firebase project needed
+ *   firebase           → your real Firebase project (config from .env)
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { initializeApp } from 'pyric/app';
+import { initializeSandbox } from 'pyric/sandbox';
+import { getFirestore, collection, getDocs, sandbox as sandboxOps } from 'pyric/firestore';
+import { seed } from './seed.js';
+const target = process.env.PYRIC_TARGET ?? 'sandbox';
+const app =
+  target === 'firebase'
+    ? initializeApp({
+        apiKey: process.env.FIREBASE_API_KEY,
+        authDomain: process.env.FIREBASE_AUTH_DOMAIN,
+        projectId: process.env.FIREBASE_PROJECT_ID,
+        appId: process.env.FIREBASE_APP_ID,
+      })
+    : initializeApp({ sandbox: initializeSandbox() });
+const db = getFirestore(app);
+if (target !== 'firebase') {
+  // Sandbox mode: deploy this project's rules into the sandbox so they
+  // actually take effect during development. \`setRules\` throws if the
+  // rules fail lint — surfacing problems at setup time is the point.
+  const rulesPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'firestore.rules');
+  sandboxOps.setRules(db, readFileSync(rulesPath, 'utf8'));
+  await seed(db);
+}
+const snap = await getDocs(collection(db, 'posts'));
+console.log(\`\${snap.size} posts:\`);
+snap.forEach((doc) => console.log(\`  \${doc.id}:\`, doc.data()));
+// Graduation: fill .env from the Firebase console, tighten firestore.rules,
+// \`pyric deploy rules\`, then run the SAME code against the real backend:
+//   PYRIC_TARGET=firebase bun start
+// (rules deploys and seeding never run in firebase mode.)
+`;
+const NODE_SEED_TS = `import { collection, addDoc, type Firestore } from 'pyric/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 = `# PYRIC_TARGET=sandbox (default) | firebase
+# For firebase mode, fill from the Firebase console (project settings):
+PYRIC_TARGET=
+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 \`pyric deploy rules\`
+    // ever hits production** — 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-shaped app, running locally on Pyric's in-process sandbox.
+No Firebase project, no emulator suite, no credentials needed to start.
+## Quick start
+\`\`\`bash
+bun install
+bun start          # runs src/app.ts against the local sandbox
+\`\`\`
+## 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 an env 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: add a \`.firebaserc\`
+   (\`{ "projects": { "default": "your-project-id" } }\`), set
+   \`GOOGLE_APPLICATION_CREDENTIALS\`, then \`pyric deploy rules\`.
+4. Run the same code against the real backend:
+   \`PYRIC_TARGET=firebase bun start\`
+`;
+// ─── web template (Vite + pyric-tools/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-tools/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-tools/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-tools/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:** \`bun run deploy:rules\` then \`bun run deploy:hosting\`
+  (\`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-tools/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',
+            'deploy:rules': 'pyric deploy rules',
+            'deploy:hosting': 'pyric deploy hosting',
+        },
+        // 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-tools': '*', 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: 'bun src/app.ts',
+            dev: 'bun --watch src/app.ts',
+            bridge: 'pyric bridge',
+            'deploy:rules': 'pyric deploy rules',
+        },
+        dependencies: { pyric: '*', 'pyric-tools': '*' },
+        devDependencies: { '@types/bun': 'latest', 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 start', 'pyric bridge  # agents: the pyric Claude Code plugin auto-connects'],
+    },
+    // 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',
+            'deploy:rules': 'pyric deploy rules',
+            'deploy:hosting': 'pyric deploy hosting',
+        },
+        dependencies: { firebase: '^12.12.0' },
+        devDependencies: { 'pyric-tools': '*' },
+        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=init-templates.js.map

package/dist/cli/init-templates.js.map ADDED Viewed

@@ -0,0 +1 @@

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