@forgeailab/create-spark 0.1.2 → 0.2.0

package/packs/payments-stripe/files/lib/stripe.ts

@@ -1,9 +1,107 @@
-import {
-  createStripeClient,
-  createCheckoutSession as createStripeCheckoutSession,
-  createBillingPortalSession as createStripeBillingPortalSession,
-  verifyWebhookSignature as verifyStripeWebhookSignature,
-} from '@forgeailab/spark-stripe-helpers';
+import Stripe from 'stripe';
+
+type StripeClientOptions = ConstructorParameters<typeof Stripe>[1];
+
+declare module 'stripe' {
+  namespace Stripe {
+    export type StripeConstructorOptions = StripeClientOptions;
+  }
+}
+
+export function createStripeClient(
+  secretKey: string,
+  options?: Stripe.StripeConstructorOptions,
+): Stripe {
+  return new Stripe(secretKey, options);
+}
+
+type CheckoutSessionCreateParams = NonNullable<
+  Parameters<Stripe['checkout']['sessions']['create']>[0]
+>;
+
+export type CreateCheckoutSessionInput = {
+  priceId: string;
+  customerId?: string;
+  customerEmail?: string;
+  successUrl: string;
+  cancelUrl: string;
+  mode?: CheckoutSessionCreateParams['mode'];
+  metadata?: Record<string, string>;
+};
+
+async function createStripeCheckoutSession(
+  stripeClient: Stripe,
+  {
+    priceId,
+    customerId,
+    customerEmail,
+    successUrl,
+    cancelUrl,
+    mode = 'subscription',
+    metadata,
+  }: CreateCheckoutSessionInput,
+): Promise<{ url: string; sessionId: string }> {
+  if (!customerId && !customerEmail) {
+    throw new Error('customerId or customerEmail is required');
+  }
+
+  const session = await stripeClient.checkout.sessions.create({
+    mode,
+    customer: customerId,
+    customer_email: customerId ? undefined : customerEmail,
+    line_items: [
+      {
+        price: priceId,
+        quantity: 1,
+      },
+    ],
+    allow_promotion_codes: true,
+    success_url: successUrl,
+    cancel_url: cancelUrl,
+    metadata,
+  });
+
+  if (!session.url) {
+    throw new Error('Stripe did not return a checkout URL');
+  }
+
+  return {
+    url: session.url,
+    sessionId: session.id,
+  };
+}
+
+export type VerifyWebhookSignatureInput = {
+  payload: string | Buffer;
+  signatureHeader: string;
+  secret: string;
+};
+
+function verifyStripeWebhookSignature(
+  stripeClient: Stripe,
+  { payload, signatureHeader, secret }: VerifyWebhookSignatureInput,
+): Promise<Stripe.Event> {
+  return stripeClient.webhooks.constructEventAsync(payload, signatureHeader, secret);
+}
+
+export type CreateBillingPortalSessionInput = {
+  customerId: string;
+  returnUrl: string;
+};
+
+async function createStripeBillingPortalSession(
+  stripeClient: Stripe,
+  { customerId, returnUrl }: CreateBillingPortalSessionInput,
+): Promise<{ url: string }> {
+  const session = await stripeClient.billingPortal.sessions.create({
+    customer: customerId,
+    return_url: returnUrl,
+  });
+
+  return {
+    url: session.url,
+  };
+}
 
 function requireEnv(name: string): string {
   const value = process.env[name];

package/packs/payments-stripe/pack.toml

@@ -8,12 +8,8 @@ conflicts = ["payments"]
 requires_runtime = ["server"]
 compatible_scaffolds = ["nextjs"]
 
-[runtime_package]
-package = "@forgeailab/spark-stripe-helpers"
-version = "^0.1"
-
 [dependencies]
-runtime = ["@stripe/stripe-js"]
+runtime = ["@stripe/stripe-js", "stripe"]
 
 [env]
 required = [

package/packs/sync-zero/files/components/ZeroProvider.tsx

@@ -1,3 +1,13 @@
 'use client';
 
-export { ZeroProvider } from '@forgeailab/spark-sync-zero';
+import type { ReactNode } from 'react';
+import type { ZeroOptions } from '@rocicorp/zero';
+import { ZeroProvider as RocicorpZeroProvider } from '@rocicorp/zero/react';
+
+type ZeroProviderProps = ZeroOptions & {
+  children: ReactNode;
+};
+
+export function ZeroProvider({ children, ...options }: ZeroProviderProps) {
+  return <RocicorpZeroProvider {...options}>{children}</RocicorpZeroProvider>;
+}

package/packs/sync-zero/files/lib/zero/client.ts

@@ -1,7 +1,7 @@
 'use client';
 
-import { createZeroClient as createSparkZeroClient } from '@forgeailab/spark-sync-zero';
-import type { ZeroOptions } from '@forgeailab/spark-sync-zero';
+import { Zero } from '@rocicorp/zero';
+import type { ZeroOptions } from '@rocicorp/zero';
 import { schema } from './schema';
 
 const DEFAULT_ZERO_URL = 'http://localhost:4848';
@@ -14,5 +14,5 @@ export function createZeroOptions(): ZeroOptions {
 }
 
 export function createZeroClient(options: ZeroOptions = createZeroOptions()) {
-  return createSparkZeroClient(options);
+  return new Zero(options);
 }

package/packs/sync-zero/files/lib/zero/schema.ts

@@ -1,4 +1,12 @@
-import { defineZeroSchema, number, string, table } from '@forgeailab/spark-sync-zero';
+import {
+  ANYONE_CAN,
+  createBuilder,
+  createSchema,
+  definePermissions,
+  number,
+  string,
+  table,
+} from '@rocicorp/zero';
 
 // Example schema. Replace with your app's tables.
 const users = table('user')
@@ -10,8 +18,13 @@ const users = table('user')
   })
   .primaryKey('id');
 
-export const { schema, zql } = defineZeroSchema({
+export const schema = createSchema({
   tables: [users],
 });
+export const zql = createBuilder(schema);
 
 export type Schema = typeof schema;
+
+export const permissions = definePermissions<unknown, Schema>(schema, () => ({
+  user: { row: { select: ANYONE_CAN } },
+}));

package/packs/sync-zero/pack.toml

@@ -8,10 +8,6 @@ conflicts = ["sync"]
 requires_runtime = ["server"]
 compatible_scaffolds = ["nextjs"]
 
-[runtime_package]
-package = "@forgeailab/spark-sync-zero"
-version = "^0.1"
-
 [dependencies]
 runtime = ["@rocicorp/zero"]
 

package/scripts/sync-skills.ts

@@ -0,0 +1,223 @@
+import { mkdtemp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  parseSkillFrontmatter,
+  serializeSkillFrontmatter,
+  toCodexFrontmatter,
+} from "../packages/spark/src/internal/skill-utils.ts";
+
+type SkillOutput = {
+  name: string;
+  content: string;
+};
+
+type Diff =
+  | { type: "missing"; path: string }
+  | { type: "extra"; path: string }
+  | { type: "changed"; path: string };
+
+type SyncResult = {
+  ok: boolean;
+  count: number;
+  diffs: Diff[];
+};
+
+type TreeEntry = {
+  type: "dir" | "file";
+  content?: string;
+};
+
+export function transformSkillMarkdown(markdown: string, skillName: string): string {
+  const { frontmatter, body } = parseSkillFrontmatter(markdown);
+  const codexFrontmatter = toCodexFrontmatter(frontmatter);
+  const outputFrontmatter = serializeSkillFrontmatter(codexFrontmatter, {
+    trailingComments: [
+      `# Generated from .claude/skills/${skillName}/SKILL.md — DO NOT EDIT directly`,
+    ],
+  });
+
+  return `---\n${outputFrontmatter}\n---\n${body}`;
+}
+
+async function collectSkillOutputs(root: string): Promise<SkillOutput[]> {
+  const sourceRoot = join(root, ".claude", "skills");
+  const entries = await readdir(sourceRoot, { withFileTypes: true });
+  const outputs: SkillOutput[] = [];
+
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    const skillName = entry.name;
+    const sourceFile = join(sourceRoot, skillName, "SKILL.md");
+    if (!existsSync(sourceFile)) {
+      continue;
+    }
+
+    const source = await readFile(sourceFile, "utf8");
+    outputs.push({
+      name: skillName,
+      content: transformSkillMarkdown(source, skillName),
+    });
+  }
+
+  return outputs;
+}
+
+async function writeOutputs(targetRoot: string, outputs: SkillOutput[]): Promise<void> {
+  await rm(targetRoot, { force: true, recursive: true });
+  await mkdir(targetRoot, { recursive: true });
+
+  for (const output of outputs) {
+    const skillDir = join(targetRoot, output.name);
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(join(skillDir, "SKILL.md"), output.content, "utf8");
+  }
+}
+
+async function collectTree(root: string): Promise<Map<string, TreeEntry>> {
+  const tree = new Map<string, TreeEntry>();
+
+  if (!existsSync(root)) {
+    return tree;
+  }
+
+  async function walk(dir: string): Promise<void> {
+    const entries = await readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const absolutePath = join(dir, entry.name);
+      const relativePath = relative(root, absolutePath).split(sep).join("/");
+
+      if (entry.isDirectory()) {
+        tree.set(relativePath, { type: "dir" });
+        await walk(absolutePath);
+        continue;
+      }
+
+      if (entry.isFile()) {
+        tree.set(relativePath, {
+          type: "file",
+          content: await readFile(absolutePath, "utf8"),
+        });
+      }
+    }
+  }
+
+  await walk(root);
+  return tree;
+}
+
+async function diffTrees(expectedRoot: string, actualRoot: string): Promise<Diff[]> {
+  const expected = await collectTree(expectedRoot);
+  const actual = await collectTree(actualRoot);
+  const paths = Array.from(new Set([...expected.keys(), ...actual.keys()])).sort();
+  const diffs: Diff[] = [];
+
+  for (const path of paths) {
+    const expectedEntry = expected.get(path);
+    const actualEntry = actual.get(path);
+
+    if (!expectedEntry) {
+      diffs.push({ type: "extra", path });
+      continue;
+    }
+
+    if (!actualEntry) {
+      diffs.push({ type: "missing", path });
+      continue;
+    }
+
+    if (
+      expectedEntry.type !== actualEntry.type ||
+      (expectedEntry.type === "file" && expectedEntry.content !== actualEntry.content)
+    ) {
+      diffs.push({ type: "changed", path });
+    }
+  }
+
+  return diffs;
+}
+
+export async function syncSkills(
+  targetRoot = process.cwd(),
+  options: { check?: boolean } = {},
+): Promise<SyncResult> {
+  const root = resolve(targetRoot);
+  const targetRootPath = join(root, ".codex", "skills");
+  const outputs = await collectSkillOutputs(root);
+
+  if (!options.check) {
+    await writeOutputs(targetRootPath, outputs);
+    return { ok: true, count: outputs.length, diffs: [] };
+  }
+
+  const tempRoot = await mkdtemp(join(tmpdir(), "sync-skills-"));
+  const expectedRoot = join(tempRoot, "skills");
+
+  try {
+    await writeOutputs(expectedRoot, outputs);
+    const diffs = await diffTrees(expectedRoot, targetRootPath);
+    return { ok: diffs.length === 0, count: outputs.length, diffs };
+  } finally {
+    await rm(tempRoot, { force: true, recursive: true });
+  }
+}
+
+function parseArgs(argv: string[]): { check: boolean; root: string } {
+  const positional: string[] = [];
+  let check = false;
+
+  for (const arg of argv) {
+    if (arg === "--check") {
+      check = true;
+      continue;
+    }
+
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+
+    positional.push(arg);
+  }
+
+  if (positional.length > 1) {
+    throw new Error("Expected at most one positional argument: target project root");
+  }
+
+  return {
+    check,
+    root: positional[0] ?? process.cwd(),
+  };
+}
+
+function printDiffs(diffs: Diff[]): void {
+  for (const diff of diffs) {
+    console.error(`${diff.type}: ${diff.path}`);
+  }
+}
+
+if (import.meta.main) {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    const result = await syncSkills(args.root, { check: args.check });
+
+    if (!result.ok) {
+      console.error(".codex/skills is out of sync. Run bun run scripts/sync-skills.ts.");
+      printDiffs(result.diffs);
+      process.exit(1);
+    }
+
+    if (args.check) {
+      console.log(`.codex/skills is in sync (${result.count} skills).`);
+    } else {
+      console.log(`Synced ${result.count} skills into .codex/skills.`);
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}