create-agent-rig 0.9.1 → 0.10.1

package/templates/skeleton/aws-serverless/services/worker/package.json

@@ -1,12 +0,0 @@
-{
-  "name": "@app/worker",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "main": "src/main.ts",
-  "types": "src/main.ts",
-  "dependencies": {
-    "@app/core": "workspace:*",
-    "@app/shared": "workspace:*"
-  }
-}

package/templates/skeleton/aws-serverless/services/worker/src/handlers/note-created.ts

@@ -1,15 +0,0 @@
-import type { SQSEvent } from 'aws-lambda';
-import type { ProcessDeps } from '../usecases/process-note-created.js';
-import { processNoteCreated } from '../usecases/process-note-created.js';
-
-/**
- * The event source uses batchSize 1, so a throw fails exactly this message and
- * SQS redrives it (then the DLQ takes over). Keep the handler a thin loop.
- */
-export function makeNoteCreatedHandler(deps: ProcessDeps) {
-  return async (event: SQSEvent): Promise<void> => {
-    for (const record of event.Records) {
-      await processNoteCreated(record.body, deps);
-    }
-  };
-}

package/templates/skeleton/aws-serverless/services/worker/src/main.ts

@@ -1,7 +0,0 @@
-// Composition root for the worker Lambda.
-import { createLogger } from '@app/shared';
-import { makeNoteCreatedHandler } from './handlers/note-created.js';
-
-export const handler = makeNoteCreatedHandler({
-  log: createLogger({ service: 'worker' }),
-});

package/templates/skeleton/aws-serverless/services/worker/src/usecases/process-note-created.ts

@@ -1,37 +0,0 @@
-// Queue discipline: validate the message against the shared event schema; a
-// message that does not parse is poison — throw, let SQS retry it, and after
-// maxReceiveCount the DLQ (with its alarm) catches it. Never swallow poison.
-import { NoteCreatedEventSchema, type NoteCreatedEvent } from '@app/core';
-import { ValidationError, type Logger } from '@app/shared';
-
-export interface ProcessDeps {
-  log: Logger;
-}
-
-export function parseNoteCreatedEvent(raw: string): NoteCreatedEvent {
-  let candidate: unknown;
-  try {
-    candidate = JSON.parse(raw);
-  } catch {
-    throw new ValidationError('message body is not JSON');
-  }
-  const parsed = NoteCreatedEventSchema.safeParse(candidate);
-  if (!parsed.success) {
-    throw new ValidationError(
-      'message is not a note.created event',
-      parsed.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`),
-    );
-  }
-  return parsed.data;
-}
-
-export async function processNoteCreated(raw: string, deps: ProcessDeps): Promise<void> {
-  const event = parseNoteCreatedEvent(raw);
-  // The skeleton's "processing" is deliberately small: acknowledge the note.
-  // Replace this with real downstream work; keep the validate-first shape.
-  deps.log.info('note.created processed', {
-    noteId: event.note.id,
-    slug: event.note.slug,
-    tagCount: event.note.tags.length,
-  });
-}

package/templates/skeleton/aws-serverless/services/worker/test/note-created.test.ts

@@ -1,61 +0,0 @@
-import type { SQSEvent } from 'aws-lambda';
-import { createNote, makeNoteCreatedEvent } from '@app/core';
-import { ValidationError, createLogger } from '@app/shared';
-import { describe, expect, it } from 'vitest';
-import { makeNoteCreatedHandler } from '../src/handlers/note-created.js';
-import { parseNoteCreatedEvent, processNoteCreated } from '../src/usecases/process-note-created.js';
-
-const note = createNote({ title: 'Hello' }, { id: 'n1', createdAt: '2024-01-01T00:00:00.000Z' });
-const validBody = JSON.stringify(makeNoteCreatedEvent(note));
-
-const sqsEvent = (...bodies: string[]): SQSEvent =>
-  ({ Records: bodies.map((body) => ({ body })) }) as SQSEvent;
-
-function collectLogs() {
-  const lines: string[] = [];
-  return { log: createLogger({}, (line) => lines.push(line)), lines };
-}
-
-describe('parseNoteCreatedEvent', () => {
-  it('parses a valid event', () => {
-    expect(parseNoteCreatedEvent(validBody).note.id).toBe('n1');
-  });
-
-  it('throws ValidationError for non-JSON bodies', () => {
-    expect(() => parseNoteCreatedEvent('not json')).toThrow(ValidationError);
-  });
-
-  it('throws ValidationError for JSON that is not a note.created event', () => {
-    expect(() => parseNoteCreatedEvent(JSON.stringify({ type: 'other' }))).toThrow(
-      ValidationError,
-    );
-  });
-});
-
-describe('processNoteCreated', () => {
-  it('logs the processed note', async () => {
-    const { log, lines } = collectLogs();
-    await processNoteCreated(validBody, { log });
-    expect(lines.join('\n')).toContain('n1');
-  });
-
-  it('lets poison messages throw — the DLQ is the safety net, not a catch block', async () => {
-    const { log } = collectLogs();
-    await expect(processNoteCreated('poison', { log })).rejects.toThrow(ValidationError);
-  });
-});
-
-describe('makeNoteCreatedHandler', () => {
-  it('processes every record in the batch', async () => {
-    const { log, lines } = collectLogs();
-    await makeNoteCreatedHandler({ log })(sqsEvent(validBody, validBody));
-    expect(lines).toHaveLength(2);
-  });
-
-  it('propagates the failure of a poison record', async () => {
-    const { log } = collectLogs();
-    await expect(makeNoteCreatedHandler({ log })(sqsEvent('poison'))).rejects.toThrow(
-      ValidationError,
-    );
-  });
-});

package/templates/skeleton/aws-serverless/tsconfig.base.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "esModuleInterop": true,
-    "isolatedModules": true,
-    "resolveJsonModule": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "types": ["node"]
-  }
-}

package/templates/skeleton/aws-serverless/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "./tsconfig.base.json",
-  "compilerOptions": {
-    "noEmit": true
-  },
-  "include": [
-    "packages/*/src/**/*.ts",
-    "packages/*/test/**/*.ts",
-    "services/*/src/**/*.ts",
-    "services/*/test/**/*.ts",
-    "infra/bin/**/*.ts",
-    "infra/lib/**/*.ts",
-    "infra/test/**/*.ts",
-    "vitest.config.ts"
-  ]
-}

package/templates/skeleton/aws-serverless/vitest.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    include: [
-      'packages/*/test/**/*.test.ts',
-      'services/*/test/**/*.test.ts',
-      'apps/*/test/**/*.test.ts',
-      'infra/test/**/*.test.ts',
-    ],
-    // CDK assertion tests bundle the Lambda entries with esbuild.
-    testTimeout: 120_000,
-  },
-});

package/templates/skeleton/node-service/.github/workflows/ci.yml

@@ -1,27 +0,0 @@
-name: CI
-
-# The default token is read-only for this job: CI needs nothing else, and a
-# workflow that can write is a workflow a compromised dependency can write with.
-permissions:
-  contents: read
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  ci:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v4
-        with:
-          version: 11
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          cache: pnpm
-      - run: pnpm install --frozen-lockfile
-      - run: pnpm lint
-      - run: pnpm typecheck
-      - run: pnpm test

package/templates/skeleton/node-service/.github/workflows/deploy.yml

@@ -1,29 +0,0 @@
-name: Build artifact
-
-# node-service ships NO deploy destination — a container registry, a VPS, a
-# PaaS is the project owner's choice, not the starter's. This builds a runnable
-# artifact (dist/) and stops short of delivery: it produces something real,
-# then leaves shipping to you. Production is a HUMAN step (see README).
-on:
-  push:
-    branches: [main, master]
-  workflow_dispatch:
-
-jobs:
-  build-artifact:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          cache: pnpm
-      - run: pnpm install --frozen-lockfile
-      - run: pnpm build:web
-      - run: pnpm build:artifact
-      - uses: actions/upload-artifact@v4
-        with:
-          name: server-bundle
-          path: dist/
-      - run: echo "Artifact built (dist/). Deploy destination is your choice — see README (Deploy)."

package/templates/skeleton/node-service/README.md

@@ -1,104 +0,0 @@
-# __PROJECT_NAME__
-
-A plain Node service generated by `create-agent-rig`, target
-`node-service`. Same architecture as every target — pure core, mandatory
-usecase layer, single-owner storage model, queue with DLQ discipline — with no
-cloud: HTTP via `node:http`, storage in a JSON file, the queue as a spool
-directory, the worker as a process. This project is yours: **delete what you
-don't need.**
-
-## Layout
-
-```
-packages/core/     pure domain: zod schemas + createNote()  (no I/O — hook-enforced)
-packages/shared/   logger, loadEnv(zod), typed errors
-packages/db/       JsonFileNoteStore — the only code touching the data file
-services/api/      POST /notes + GET /notes: payload → handler → usecase → model;
-                   also serves the built web bundle (no second runtime)
-services/worker/   spool consumer (3 attempts → var/dlq + ALARM log line)
-apps/web/          static Next export; validates with the SAME core schema the
-                   server trusts (imports core+shared only — hook-enforced)
-.claude/           the agent operating system: rules, gates, blocking hooks
-```
-
-The agent-facing map is `CLAUDE.md`; the rules live in `.claude/rules/`.
-
-## Run it
-
-```sh
-pnpm install
-pnpm test
-pnpm lint
-pnpm typecheck
-pnpm check       # all of the above
-```
-
-Start the service (two processes; build the web bundle first to get the UI):
-
-```sh
-pnpm build:web      # static Next export → apps/web/out
-pnpm start:api      # PORT=3000; serves the API and apps/web/out at /
-pnpm start:worker   # polls var/queue, dead-letters into var/dlq
-```
-
-Open http://localhost:3000/ — the form validates with the same core schema
-the server applies again on POST.
-
-Configuration is environment-first (`PORT`, `DATA_DIR`, `QUEUE_DIR`, `DLQ_DIR`,
-`POLL_INTERVAL_MS`, `STATIC_DIR`) with working defaults — see each service's
-`main.ts`.
-
-## Deploy it
-
-This target ships **no deploy destination** — a container registry, a VPS, a
-PaaS is your choice, not the starter's. What it ships is a **build that
-produces a runnable artifact** and stops there:
-
-```sh
-pnpm build:artifact                       # → dist/server.mjs + dist/public/
-STATIC_DIR=dist/public node dist/server.mjs   # run the artifact anywhere Node runs
-```
-
-`.github/workflows/deploy.yml` runs this on every push and uploads `dist/` as a
-build artifact — it produces something real and delivers it nowhere. Point it
-at your host of choice (add a `docker build`, an `scp`, a PaaS deploy step).
-
-**Production is a human step, on purpose.** The agent operating system's Never
-tier forbids an agent from triggering a production deploy, so no automated prod
-path ships here — promoting the artifact to production is your reviewed action.
-
-## Verify runtime health (CI-green ≠ runtime-healthy)
-
-```sh
-curl -s -X POST localhost:3000/notes \
-  -H 'content-type: application/json' \
-  -d '{"title":"smoke test","tags":["deploy"]}'
-# expect: HTTP 201 with { "note": { … } }
-```
-
-Then confirm the pipeline: the worker logs `note.created processed`, and
-**`var/dlq/` stays empty** (an `ALARM` log line means a message was
-dead-lettered). On regression: roll back to the previous revision first,
-diagnose second.
-
-## Boundaries (the short version)
-
-- Every request follows `payload → handler → usecase → model`. The usecase
-  layer is mandatory even when it looks like ceremony.
-- `packages/core` is pure — the `guard-core-purity` hook refuses I/O, clock,
-  randomness, and environment access at the tool layer.
-- `packages/db` is the only module that touches the stored data. It is a
-  **single-instance store**: writes serialise inside one `JsonFileNoteStore`
-  object, and that is the whole of it. Two stores over the same file lose
-  notes to each other whether they sit in one process or two — share the one
-  instance, and reach for a real lock before you share the file.
-  A hard kill between the temp write and the rename leaves a `*.tmp` file
-  behind; nothing sweeps them.
-- `POST /notes` buffers at most **1 MB** of request body and answers `413` past
-  that. The cap lives in that route, not in the shell: a new route that reads a
-  body adds its own. Raise it in `services/api/src/server.ts` if your payloads
-  are bigger; do not remove it.
-- A failing queue message is poison: it throws, the spool retries ×3, then the
-  DLQ gets it and the ALARM line fires. Never wrap the worker in a broad catch.
-
-See `.claude/rules/architecture.md` for the full rules.

package/templates/skeleton/node-service/apps/web/next.config.mjs

@@ -1,17 +0,0 @@
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  // Static export: one build, no second runtime — the API server (or a CDN)
-  // serves the bundle. See README for how this target serves it.
-  output: 'export',
-  // The core ships as TypeScript source; Next transpiles it for the browser.
-  transpilePackages: ['@app/core'],
-  // The core uses NodeNext-style relative imports ("./note.js" resolving to
-  // note.ts). Turbopack cannot map that, so the build runs webpack (see the
-  // build script) with the standard extension alias.
-  webpack: (config) => {
-    config.resolve.extensionAlias = { '.js': ['.ts', '.tsx', '.js'] };
-    return config;
-  },
-};
-
-export default nextConfig;

package/templates/skeleton/node-service/apps/web/package.json

@@ -1,19 +0,0 @@
-{
-  "name": "@app/web",
-  "version": "0.1.0",
-  "private": true,
-  "scripts": {
-    "dev": "next dev --port 3001 --webpack",
-    "build": "next build --webpack"
-  },
-  "dependencies": {
-    "@app/core": "workspace:*",
-    "next": "^16.2.11",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8"
-  },
-  "devDependencies": {
-    "@types/react": "^19.2.17",
-    "@types/react-dom": "^19.2.3"
-  }
-}

package/templates/skeleton/node-service/apps/web/src/app/layout.tsx

@@ -1,17 +0,0 @@
-import type { ReactNode } from 'react';
-
-// Deliberately unstyled: a starter's frontend is scaffolding, not a product.
-// Polish belongs in the mechanism (the shared validation, the boundary hook),
-// not in the pixels — replace all of this freely.
-export const metadata = {
-  title: '__PROJECT_NAME__',
-  description: 'Notes — generated by create-agent-rig',
-};
-
-export default function RootLayout({ children }: { children: ReactNode }) {
-  return (
-    <html lang="en">
-      <body>{children}</body>
-    </html>
-  );
-}

package/templates/skeleton/node-service/apps/web/src/app/page.tsx

@@ -1,96 +0,0 @@
-'use client';
-// One page, one point: the SAME domain schema validates here (instant
-// feedback) and on the server (trust). See src/lib/validate.ts.
-import { useCallback, useEffect, useState } from 'react';
-import type { Note } from '@app/core';
-import { createNote, listNotes } from '../lib/api';
-import { validateNewNote } from '../lib/validate';
-
-export default function NotesPage() {
-  const [title, setTitle] = useState('');
-  const [tags, setTags] = useState('');
-  const [issues, setIssues] = useState<string[]>([]);
-  const [notes, setNotes] = useState<Note[]>([]);
-  const [status, setStatus] = useState<string>('');
-
-  const refresh = useCallback(async () => {
-    try {
-      setNotes(await listNotes());
-      setStatus('');
-    } catch (error) {
-      setStatus(`could not load notes: ${String(error)}`);
-    }
-  }, []);
-
-  useEffect(() => {
-    void refresh();
-  }, [refresh]);
-
-  async function onSubmit(event: React.FormEvent) {
-    event.preventDefault();
-    const input = {
-      title,
-      tags: tags
-        .split(',')
-        .map((tag) => tag.trim())
-        .filter(Boolean),
-    };
-    // Client-side: the same core schema the server will apply again.
-    const verdict = validateNewNote(input);
-    setIssues(verdict.issues);
-    if (!verdict.ok) return;
-    try {
-      await createNote(input);
-      setTitle('');
-      setTags('');
-      await refresh();
-    } catch (error) {
-      setIssues([String(error)]);
-    }
-  }
-
-  return (
-    <main>
-      <h1>Notes</h1>
-      <p>
-        The form validates with the <em>same</em> core function the server
-        trusts — one schema, both sides of the wire.
-      </p>
-
-      <form onSubmit={onSubmit}>
-        <label>
-          Title{' '}
-          <input
-            name="title"
-            value={title}
-            onChange={(event) => setTitle(event.target.value)}
-          />
-        </label>{' '}
-        <label>
-          Tags (comma-separated){' '}
-          <input name="tags" value={tags} onChange={(event) => setTags(event.target.value)} />
-        </label>{' '}
-        <button type="submit">Create</button>
-      </form>
-
-      {issues.length > 0 && (
-        <ul role="alert">
-          {issues.map((issue) => (
-            <li key={issue}>{issue}</li>
-          ))}
-        </ul>
-      )}
-      {status && <p role="status">{status}</p>}
-
-      <h2>Existing</h2>
-      <ul>
-        {notes.map((note) => (
-          <li key={note.id}>
-            <strong>{note.title}</strong> <code>{note.slug}</code>{' '}
-            <small>{note.tags.join(', ')}</small>
-          </li>
-        ))}
-      </ul>
-    </main>
-  );
-}

package/templates/skeleton/node-service/apps/web/src/lib/api.ts

@@ -1,29 +0,0 @@
-// The web talks to the backend over HTTP only — never by importing it
-// (the guard-web-boundary hook refuses such imports at the tool layer).
-import type { Note } from '@app/core';
-
-// Same-origin by default (the API server serves this bundle); set
-// NEXT_PUBLIC_API_URL at build time when the API lives elsewhere.
-const base = process.env.NEXT_PUBLIC_API_URL ?? '';
-
-export async function createNote(input: { title: string; tags: string[] }): Promise<Note> {
-  const response = await fetch(`${base}/notes`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify(input),
-  });
-  const body = (await response.json()) as { note?: Note; error?: string; issues?: string[] };
-  if (!response.ok || !body.note) {
-    throw new Error(body.issues?.join('; ') ?? body.error ?? `HTTP ${response.status}`);
-  }
-  return body.note;
-}
-
-export async function listNotes(): Promise<Note[]> {
-  const response = await fetch(`${base}/notes`);
-  const body = (await response.json()) as { notes?: Note[]; error?: string };
-  if (!response.ok || !body.notes) {
-    throw new Error(body.error ?? `HTTP ${response.status}`);
-  }
-  return body.notes;
-}

package/templates/skeleton/node-service/apps/web/src/lib/validate.ts

@@ -1,23 +0,0 @@
-// The load-bearing import of this whole app: the browser validates with the
-// SAME schema the server trusts. Client-side for instant feedback,
-// server-side for trust — one function, two sides of the wire. This is what
-// core purity buys: `@app/core` has no I/O, so it runs anywhere.
-import { NewNoteSchema } from '@app/core';
-
-export interface ValidationResult {
-  ok: boolean;
-  issues: string[];
-}
-
-export function validateNewNote(input: unknown): ValidationResult {
-  const parsed = NewNoteSchema.safeParse(input);
-  if (parsed.success) {
-    return { ok: true, issues: [] };
-  }
-  return {
-    ok: false,
-    issues: parsed.error.issues.map(
-      (issue) => `${issue.path.join('.') || 'input'}: ${issue.message}`,
-    ),
-  };
-}

package/templates/skeleton/node-service/apps/web/test/shared-validation.test.ts

@@ -1,38 +0,0 @@
-// THE load-bearing test of the frontend (web brief §5): the browser-side
-// validator and the server-side schema must be the same decision procedure.
-// No jsdom, no rendering — the boundary is the point, not the pixels.
-import { InvalidNoteError, NewNoteSchema, createNote } from '@app/core';
-import { describe, expect, it } from 'vitest';
-import { validateNewNote } from '../src/lib/validate';
-
-const identity = { id: 'n1', createdAt: '2024-01-01T00:00:00.000Z' };
-
-const CASES: Array<{ name: string; input: unknown }> = [
-  { name: 'valid minimal', input: { title: 'Hello' } },
-  { name: 'valid with tags', input: { title: 'Hello', tags: ['a', 'b'] } },
-  { name: 'empty title', input: { title: '' } },
-  { name: 'whitespace title', input: { title: '   ' } },
-  { name: 'title too long', input: { title: 'x'.repeat(201) } },
-  { name: 'too many tags', input: { title: 'T', tags: Array.from({ length: 11 }, (_, i) => `${i}`) } },
-  { name: 'empty tag', input: { title: 'T', tags: [''] } },
-  { name: 'wrong types', input: { title: 42 } },
-  { name: 'not an object', input: 'nope' },
-];
-
-describe('one schema, both sides of the wire', () => {
-  for (const { name, input } of CASES) {
-    it(`web and core agree on: ${name}`, () => {
-      const webVerdict = validateNewNote(input);
-      const coreVerdict = NewNoteSchema.safeParse(input);
-      expect(webVerdict.ok).toBe(coreVerdict.success);
-
-      // …and the domain function (used by the API usecase) agrees with both.
-      if (coreVerdict.success) {
-        expect(() => createNote(input, identity)).not.toThrow();
-      } else {
-        expect(() => createNote(input, identity)).toThrow(InvalidNoteError);
-        expect(webVerdict.issues.length).toBeGreaterThan(0);
-      }
-    });
-  }
-});

package/templates/skeleton/node-service/apps/web/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "jsx": "preserve",
-    "lib": ["dom", "dom.iterable", "es2022"],
-    "noEmit": true,
-    "allowJs": true,
-    "plugins": [{ "name": "next" }]
-  },
-  "include": ["src/**/*.ts", "src/**/*.tsx", "test/**/*.ts"],
-  "exclude": ["node_modules", "out", ".next"]
-}

package/templates/skeleton/node-service/eslint.config.mjs

@@ -1,20 +0,0 @@
-import eslint from '@eslint/js';
-import globals from 'globals';
-import tseslint from 'typescript-eslint';
-
-export default tseslint.config(
-  {
-    ignores: [
-      '**/node_modules/**',
-      '**/dist/**',
-      '**/coverage/**',
-      '**/var/**',
-      '**/.next/**',
-      '**/out/**',
-      '**/next-env.d.ts',
-    ],
-  },
-  eslint.configs.recommended,
-  ...tseslint.configs.recommended,
-  { languageOptions: { globals: globals.node } },
-);