forgedock 1.0.21 → 1.0.22

package/examples/forgedock-demo/README.md

@@ -0,0 +1,113 @@
+# ForgeDock Demo — A Risk-Free First Pipeline Run
+
+A tiny **Notes API** (~300 lines, zero dependencies) with five pre-written
+issues. It exists so you can watch ForgeDock investigate, build, review, and
+merge a change **without touching your real codebase**.
+
+> Clone → `npx forgedock` → open Claude Code → `/work-on 1` → watch it go.
+
+---
+
+## Why this exists
+
+Trying ForgeDock on your own project means trusting an AI pipeline with real
+code on your very first run. This demo removes that risk: it's a self-contained
+sandbox where every issue is small, fast, and safe to break.
+
+The API has a couple of **intentional, clearly-labelled flaws** (a missing auth
+check, an unsafe query path) so that ForgeDock's `/review-pr` agents have real
+findings to surface — that's the part that makes the review feel impressive.
+
+---
+
+## What's inside
+
+```
+forgedock-demo/
+├── src/
+│   ├── server.js        # built-in http server + router (no Express)
+│   ├── router.js        # (added by Issue #3)
+│   ├── routes/notes.js  # CRUD handlers — has the intentional flaws
+│   ├── db.js            # in-memory store
+│   └── auth.js          # bearer-token check
+├── scripts/smoke.js     # dependency-free smoke test (npm run smoke)
+├── issues/              # the 5 pre-written issue specs
+├── forge.yaml           # minimal working ForgeDock config
+├── labels.json          # workflow + priority labels
+└── bootstrap.sh         # one command to stand up the live repo
+```
+
+No database. No Docker. No API keys. Runs on Node 18+.
+
+---
+
+## Run it locally (optional)
+
+```bash
+node src/server.js          # starts on http://localhost:3000
+# in another terminal:
+curl http://localhost:3000/notes
+npm run smoke               # runs the smoke test
+```
+
+---
+
+## The five demo issues
+
+Each issue targets a different pipeline strength and is scoped to finish fast.
+
+| # | Type | Title | What it shows |
+|---|------|-------|---------------|
+| 1 | Bug / security | DELETE is missing an auth check | Simplest fix — fastest run |
+| 2 | Feature / security | Safe filtering for `GET /notes` | Investigation + architecture |
+| 3 | Refactor | Extract the router module | "No behavior change" review |
+| 4 | Performance | O(1) `findById` | Investigation phase tracing the hot path |
+| 5 | Docs | Add an API reference | Pipeline handles non-code work |
+
+Full specs live in [`issues/`](./issues). When you run `bootstrap.sh`, these
+become real GitHub issues #1–#5 in your demo repo, in this order.
+
+---
+
+## Stand up your own live demo repo
+
+The scaffold is complete and ready — the only step that needs your GitHub
+credentials is creating the actual repo. One command does it:
+
+```bash
+# requires an authenticated gh CLI (gh auth login)
+./bootstrap.sh                        # creates <your-user>/forgedock-demo (public)
+# or:
+./bootstrap.sh my-org/forgedock-demo  # custom owner/repo
+```
+
+`bootstrap.sh` will:
+
+1. Create the GitHub repo (skips if it already exists).
+2. Push this codebase to `main`.
+3. Create the workflow + priority labels (via `npx forgedock labels setup`,
+   falling back to `labels.json`).
+4. File the five issues from [`issues/`](./issues).
+
+Then:
+
+```bash
+git clone https://github.com/<you>/forgedock-demo.git
+cd forgedock-demo
+npx forgedock              # install the ForgeDock commands
+# open Claude Code in this directory, then run:
+/work-on 1
+```
+
+Watch ForgeDock investigate the missing-auth bug, write the fix, run the quality
+gate, open a PR, review it, and merge — all on a repo you can safely throw away.
+
+---
+
+## After your first run
+
+Try `/work-on 2` through `/work-on 5` to see the other pipeline phases, or run
+`/orchestrate` to let ForgeDock work several issues in parallel.
+
+When you're comfortable, point ForgeDock at your real project — you've already
+seen exactly what it does.

package/examples/forgedock-demo/bootstrap.sh

@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+#
+# bootstrap.sh — stand up a live ForgeDock demo repo from this scaffold.
+#
+# This is the ONE step that needs a human: it creates a real GitHub repo (which
+# requires your credentials), pushes this code, sets up the workflow labels, and
+# files the five demo issues. Everything else in the scaffold is ready to go.
+#
+# Usage:
+#   ./bootstrap.sh                       # creates <your-user>/forgedock-demo (public)
+#   ./bootstrap.sh my-org/forgedock-demo # custom owner/repo
+#   ./bootstrap.sh my-org/forgedock-demo --private
+#
+# Requirements: an authenticated `gh` CLI (`gh auth status`) and `git`.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+# ---- args -------------------------------------------------------------------
+REPO_SLUG="${1:-}"
+VISIBILITY="--public"
+for arg in "$@"; do
+  case "$arg" in
+    --private) VISIBILITY="--private" ;;
+    --public)  VISIBILITY="--public" ;;
+  esac
+done
+
+if [ -z "$REPO_SLUG" ] || [[ "$REPO_SLUG" == --* ]]; then
+  GH_USER="$(gh api user --jq '.login')"
+  REPO_SLUG="${GH_USER}/forgedock-demo"
+fi
+
+echo "==> Target repo: $REPO_SLUG ($VISIBILITY)"
+
+command -v gh >/dev/null || { echo "ERROR: gh CLI not found"; exit 1; }
+gh auth status >/dev/null || { echo "ERROR: run 'gh auth login' first"; exit 1; }
+
+# ---- 1. create the repo -----------------------------------------------------
+REPO_CREATED=false
+if gh repo view "$REPO_SLUG" >/dev/null 2>&1; then
+  echo "==> Repo already exists, skipping creation."
+else
+  echo "==> Creating repo..."
+  gh repo create "$REPO_SLUG" $VISIBILITY \
+    --description "Try ForgeDock risk-free — a tiny Notes API with pre-written issues." \
+    --disable-wiki
+  REPO_CREATED=true
+fi
+
+# ---- 2. push the scaffold ---------------------------------------------------
+TMP_DIR="$(mktemp -d)"
+echo "==> Staging scaffold in $TMP_DIR"
+# Copy everything except bootstrap.sh and the issues/ specs (issues become GH issues).
+cp -r src scripts package.json forge.yaml labels.json README.md .gitignore "$TMP_DIR/" 2>/dev/null || true
+# Ship the issue specs too, for reference inside the repo.
+cp -r issues "$TMP_DIR/issues"
+
+(
+  cd "$TMP_DIR"
+  git init -q
+  git checkout -q -b main
+  git add .
+  git -c user.name="forgedock-demo" -c user.email="demo@forgedock.dev" \
+      commit -q -m "chore: initial demo scaffold"
+  git remote add origin "https://github.com/${REPO_SLUG}.git"
+  if [ "$REPO_CREATED" = "true" ]; then
+    # Fresh repo we just created — safe to push.
+    git push -q -u origin main
+  else
+    # Repo pre-existed. Never force-push over someone's existing main; do a
+    # non-destructive push and let it fail loudly if the repo already has commits.
+    if ! git push -q -u origin main 2>/dev/null; then
+      echo "ERROR: '$REPO_SLUG' already has content on main. Refusing to overwrite it." >&2
+      echo "       Use a fresh/empty repo, or push manually if you intend to replace it." >&2
+      exit 1
+    fi
+  fi
+)
+echo "==> Pushed scaffold to $REPO_SLUG"
+
+# ---- 3. labels --------------------------------------------------------------
+echo "==> Creating labels..."
+# Prefer the ForgeDock CLI if available; otherwise create from labels.json.
+if command -v npx >/dev/null && npx --no-install forgedock --help >/dev/null 2>&1; then
+  npx forgedock labels setup --repo "$REPO_SLUG" || true
+else
+  node -e '
+    const fs = require("fs");
+    const labels = JSON.parse(fs.readFileSync("labels.json", "utf8"));
+    for (const l of labels) console.log([l.name, l.color, l.description].join("\t"));
+  ' labels.json | while IFS=$'\t' read -r name color desc; do
+    gh label create "$name" --color "$color" --description "$desc" --force -R "$REPO_SLUG" >/dev/null 2>&1 || true
+  done
+fi
+
+# ---- 4. issues --------------------------------------------------------------
+echo "==> Creating issues..."
+for f in issues/*.md; do
+  title="$(grep -m1 '^title:' "$f" | sed -E 's/^title:[[:space:]]*"?([^"]*)"?[[:space:]]*$/\1/')"
+  labels="$(grep -m1 '^labels:' "$f" | sed -E 's/^labels:[[:space:]]*\[(.*)\][[:space:]]*$/\1/' | tr -d '"' | tr -d ' ')"
+  # Body = everything after the closing front-matter '---'.
+  body="$(awk 'f{print} /^---[[:space:]]*$/{c++; if(c==2) f=1}' "$f")"
+  label_args=()
+  if [ -n "$labels" ]; then
+    IFS=',' read -ra parts <<< "$labels"
+    for l in "${parts[@]}"; do label_args+=(--label "$l"); done
+  fi
+  echo "    - $title"
+  gh issue create -R "$REPO_SLUG" --title "$title" --body "$body" "${label_args[@]}" >/dev/null \
+    || gh issue create -R "$REPO_SLUG" --title "$title" --body "$body" >/dev/null
+done
+
+rm -rf "$TMP_DIR"
+
+echo ""
+echo "Done. Your demo repo is ready:"
+echo "  https://github.com/${REPO_SLUG}"
+echo ""
+echo "Next:"
+echo "  git clone https://github.com/${REPO_SLUG}.git && cd forgedock-demo"
+echo "  npx forgedock           # install the commands"
+echo "  # open Claude Code here, then run:  /work-on 1"

package/examples/forgedock-demo/issues/01-bug-delete-missing-auth.md

@@ -0,0 +1,37 @@
+---
+title: "fix(notes): DELETE /notes/:id is missing an auth check"
+labels: ["bug", "security", "priority:P1"]
+---
+
+## Problem
+
+`DELETE /notes/:id` lets **anyone** delete any note. The other mutating route
+(`POST /notes`) requires a bearer token via `requireToken(req)`, but the delete
+handler skips that check entirely. This is an authorization gap.
+
+## Steps to Reproduce
+
+```bash
+# No token, yet it succeeds:
+curl -X DELETE http://localhost:3000/notes/1
+# => {"deleted":1}
+```
+
+## Affected Files
+
+1. `src/routes/notes.js` — `deleteNote()` is missing a `requireToken(req)` call.
+
+## Expected Behavior
+
+`DELETE /notes/:id` returns `401 Unauthorized` when no valid bearer token is
+supplied, matching the protection on `POST /notes`.
+
+## Acceptance Criteria
+
+- [ ] `deleteNote()` calls `requireToken(req)` before deleting.
+- [ ] Unauthenticated delete returns 401.
+- [ ] Authenticated delete (`Authorization: Bearer demo-token`) still works.
+- [ ] No regression in `npm run smoke`.
+
+> Good first run: this is the simplest issue — expect the pipeline to finish in
+> a couple of minutes.

package/examples/forgedock-demo/issues/02-feature-filter-notes.md

@@ -0,0 +1,37 @@
+---
+title: "feat(notes): add safe filtering for GET /notes"
+labels: ["feature", "security", "priority:P2"]
+---
+
+## Problem
+
+`GET /notes?where=...` forwards the raw `where` string straight into
+`db.query()`, which evaluates it as a JavaScript expression. That is an
+injection hole (a caller can pass `?where=true||secret` to leak secret notes).
+We want a **safe** way to filter notes instead.
+
+## Proposed Solution
+
+Replace the free-form `?where=` evaluation with explicit, allow-listed query
+params:
+
+- `?owner=alice` — exact match on `owner`
+- `?secret=false` — match on the `secret` boolean
+
+Build the filter from these typed params in code — never by evaluating a string.
+
+## Affected Files
+
+1. `src/routes/notes.js` — `listNotes()` should read `owner` / `secret` params.
+2. `src/db.js` — replace `query(whereClause)` with a structured filter helper
+   (e.g. `filter({ owner, secret })`) that does not evaluate strings.
+
+## Acceptance Criteria
+
+- [ ] `GET /notes?owner=alice` returns only alice's notes.
+- [ ] `GET /notes?secret=false` returns only non-secret notes.
+- [ ] The string-evaluating `db.query()` path is removed.
+- [ ] `npm run smoke` still passes.
+
+> This issue exercises the **investigation + architecture** phases — the fix
+> touches two files and removes an unsafe code path.

package/examples/forgedock-demo/issues/03-refactor-router-table.md

@@ -0,0 +1,33 @@
+---
+title: "refactor(server): extract the router into its own module"
+labels: ["refactor", "priority:P3"]
+---
+
+## Problem
+
+`src/server.js` mixes three concerns in one file: the route table, request
+body parsing, and the HTTP server wiring. As more routes are added this file
+will become hard to read and test.
+
+## Proposed Solution
+
+Extract the routing logic into a dedicated `src/router.js` module that exports
+a `route(req, res)` function (or a small `Router` object). `server.js` should
+shrink to: create the HTTP server, delegate to the router, and listen.
+
+This is a pure refactor — no behavior changes.
+
+## Affected Files
+
+1. `src/server.js` — remove the inline `TABLE` + matching logic.
+2. `src/router.js` (NEW) — owns the route table and dispatch.
+
+## Acceptance Criteria
+
+- [ ] Route table and dispatch live in `src/router.js`.
+- [ ] `server.js` only creates the server and listens.
+- [ ] All endpoints behave exactly as before.
+- [ ] `npm run smoke` still passes.
+
+> A clean refactor with zero behavior change — a good way to see how the review
+> agents confirm "no regression".

package/examples/forgedock-demo/issues/04-perf-index-lookup.md

@@ -0,0 +1,35 @@
+---
+title: "perf(db): make findById O(1) instead of a linear scan"
+labels: ["performance", "priority:P3"]
+---
+
+## Problem
+
+`db.findById(id)` and `db.remove(id)` both do a linear `Array.find` /
+`Array.filter` over every note on each call. With the seed data that is fine,
+but it is O(n) per lookup and will not scale as the note count grows.
+
+## Investigation Hint
+
+Before optimizing, confirm where the linear scans actually are and whether an
+index can stay consistent across `insert`, `remove`, and `reset`. The point of
+this issue is to show ForgeDock's **investigation phase** tracing the real hot
+path rather than guessing.
+
+## Proposed Solution
+
+Maintain an `id -> note` index (a `Map`) alongside the array so `findById` is
+O(1). Keep the index in sync in `insert`, `remove`, and `reset`.
+
+## Affected Files
+
+1. `src/db.js` — add and maintain a `Map` index; use it in `findById`.
+
+## Acceptance Criteria
+
+- [ ] `findById` uses an O(1) Map lookup.
+- [ ] The index stays consistent after `insert`, `remove`, and `reset`.
+- [ ] `npm run smoke` still passes.
+
+> This issue showcases the **investigation phase** — the agent verifies the
+> claim against the code before writing the optimization.

package/examples/forgedock-demo/issues/05-docs-api-reference.md

@@ -0,0 +1,39 @@
+---
+title: "docs(api): add an API reference for the Notes endpoints"
+labels: ["documentation", "priority:P3"]
+---
+
+## Problem
+
+The demo API has no endpoint documentation. A newcomer has to read `server.js`
+and `routes/notes.js` to learn what routes exist, which ones need a token, and
+what they return.
+
+## Proposed Solution
+
+Add `docs/API.md` documenting every endpoint:
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| GET | `/health` | no | Liveness check |
+| GET | `/notes` | no | List notes (supports filtering) |
+| GET | `/notes/:id` | no | Fetch one note |
+| POST | `/notes` | yes | Create a note |
+| DELETE | `/notes/:id` | yes | Delete a note |
+
+Include a `curl` example for each and note the `Authorization: Bearer demo-token`
+header for protected routes.
+
+## Affected Files
+
+1. `docs/API.md` (NEW) — endpoint reference.
+2. `README.md` — link to the new API reference.
+
+## Acceptance Criteria
+
+- [ ] `docs/API.md` documents all 5 endpoints with auth + examples.
+- [ ] README links to it.
+- [ ] No code changes required.
+
+> This issue proves the pipeline handles **non-code work** — docs-only changes
+> still go through investigate → build → review → merge.

package/examples/forgedock-demo/labels.json

@@ -0,0 +1,21 @@
+[
+  { "name": "priority:P0", "color": "B60205", "description": "Critical priority — production broken, data loss, security breach." },
+  { "name": "priority:P1", "color": "D93F0B", "description": "High priority — major feature broken, no workaround." },
+  { "name": "priority:P2", "color": "FBCA04", "description": "Medium priority — impaired functionality, workaround exists." },
+  { "name": "priority:P3", "color": "C2E0C6", "description": "Low priority — minor issue or polish." },
+  { "name": "workflow:investigating", "color": "1D76DB", "description": "Pipeline: investigation phase in progress." },
+  { "name": "workflow:ready-to-build", "color": "0075CA", "description": "Pipeline: investigation complete, ready for build." },
+  { "name": "workflow:building", "color": "0052CC", "description": "Pipeline: implementation in progress." },
+  { "name": "workflow:in-review", "color": "5319E7", "description": "Pipeline: PR created, under review." },
+  { "name": "workflow:merged", "color": "0E8A16", "description": "Pipeline: PR merged, issue closed." },
+  { "name": "workflow:decomposed", "color": "BFD4F2", "description": "Pipeline: decomposed into sub-issues." },
+  { "name": "workflow:invalid", "color": "CCCCCC", "description": "Pipeline: issue closed as invalid after investigation." },
+  { "name": "needs-human", "color": "E4E669", "description": "Pipeline stalled — requires human intervention." },
+  { "name": "review-finding", "color": "D93F0B", "description": "Defect or improvement found during automated PR review." },
+  { "name": "bug", "color": "D73A4A", "description": "Something isn't working." },
+  { "name": "feature", "color": "0075CA", "description": "New feature implementation." },
+  { "name": "refactor", "color": "FEF2C0", "description": "Code restructuring without behavior change." },
+  { "name": "performance", "color": "F9D0C4", "description": "Performance optimization or regression." },
+  { "name": "documentation", "color": "0075CA", "description": "Documentation addition or update." },
+  { "name": "security", "color": "B60205", "description": "Security vulnerability or hardening." }
+]

package/examples/forgedock-demo/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "forgedock-demo",
+  "version": "1.0.0",
+  "description": "A tiny, dependency-free Notes API used as a risk-free playground for trying ForgeDock.",
+  "type": "commonjs",
+  "main": "src/server.js",
+  "scripts": {
+    "start": "node src/server.js",
+    "smoke": "node scripts/smoke.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "private": true
+}

package/examples/forgedock-demo/scripts/smoke.js

@@ -0,0 +1,61 @@
+// Tiny smoke test for the demo Notes API. No test framework, no deps.
+// Starts the server on a random port, hits a few endpoints, and asserts.
+// Run with: npm run smoke
+
+const http = require('http');
+const assert = require('assert');
+const { server } = require('../src/server');
+
+function request(port, method, path, { token, json } = {}) {
+  return new Promise((resolve, reject) => {
+    const headers = {};
+    if (token) headers['Authorization'] = `Bearer ${token}`;
+    let payload;
+    if (json) {
+      payload = JSON.stringify(json);
+      headers['Content-Type'] = 'application/json';
+      headers['Content-Length'] = Buffer.byteLength(payload);
+    }
+    const req = http.request({ host: '127.0.0.1', port, method, path, headers }, (res) => {
+      let raw = '';
+      res.on('data', (c) => (raw += c));
+      res.on('end', () => resolve({ status: res.statusCode, body: raw ? JSON.parse(raw) : {} }));
+    });
+    req.on('error', reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+async function main() {
+  await new Promise((r) => server.listen(0, r));
+  const { port } = server.address();
+
+  const health = await request(port, 'GET', '/health');
+  assert.strictEqual(health.status, 200, 'health should be 200');
+  assert.strictEqual(health.body.status, 'ok', 'health status should be ok');
+
+  const list = await request(port, 'GET', '/notes');
+  assert.ok(Array.isArray(list.body.notes), 'GET /notes returns an array');
+  assert.ok(list.body.notes.length >= 3, 'seed notes present');
+
+  const created = await request(port, 'POST', '/notes', {
+    token: 'demo-token',
+    json: { title: 'smoke', owner: 'tester' },
+  });
+  assert.strictEqual(created.status, 201, 'POST with token returns 201');
+
+  const unauth = await request(port, 'POST', '/notes', { json: { title: 'nope' } });
+  assert.strictEqual(unauth.status, 401, 'POST without token returns 401');
+
+  // eslint-disable-next-line no-console
+  console.log('SMOKE OK — health, list, create(auth), create(unauth) all pass');
+  server.close();
+}
+
+main().catch((err) => {
+  // eslint-disable-next-line no-console
+  console.error('SMOKE FAILED:', err.message);
+  server.close();
+  process.exit(1);
+});

package/examples/forgedock-demo/src/auth.js

@@ -0,0 +1,28 @@
+// Minimal token-based auth for the demo Notes API.
+//
+// The "token" is just a static demo secret — there are no real users or
+// sessions. Routes that should be protected call `requireToken(req)`.
+//
+// >>> DEMO NOTE: In routes/notes.js, one mutating route deliberately does NOT
+// >>> call requireToken(). That missing-auth check is an INTENTIONAL flaw so
+// >>> ForgeDock's review agents have an authorization gap to flag.
+
+const DEMO_TOKEN = 'demo-token';
+
+// Returns true when the request carries the demo bearer token.
+function isAuthenticated(req) {
+  const header = req.headers['authorization'] || '';
+  const [scheme, value] = header.split(' ');
+  return scheme === 'Bearer' && value === DEMO_TOKEN;
+}
+
+// Throws a 401-style error when the request is not authenticated.
+function requireToken(req) {
+  if (!isAuthenticated(req)) {
+    const err = new Error('Unauthorized: missing or invalid bearer token');
+    err.statusCode = 401;
+    throw err;
+  }
+}
+
+module.exports = { isAuthenticated, requireToken, DEMO_TOKEN };

package/examples/forgedock-demo/src/db.js

@@ -0,0 +1,66 @@
+// In-memory data store for the demo Notes API.
+//
+// This is intentionally a plain array plus a deliberately naive query helper.
+// There is no real database — `query()` simulates a SQL-style WHERE clause by
+// building a predicate from a raw string. This mirrors the classic SQL-injection
+// pattern (untrusted input concatenated into a query) so that ForgeDock's
+// /review-pr security agent has a realistic finding to surface.
+//
+// >>> DEMO NOTE: The string-built filter below is an INTENTIONAL, isolated flaw.
+// >>> It exists only inside examples/forgedock-demo so the review agents have
+// >>> something to catch. Do not copy this pattern into real code.
+
+let notes = [
+  { id: 1, owner: 'alice', title: 'Buy milk', body: 'Whole milk, 2 liters', secret: false },
+  { id: 2, owner: 'alice', title: 'Launch plan', body: 'Ship the demo repo', secret: true },
+  { id: 3, owner: 'bob', title: 'Gym', body: 'Leg day', secret: false },
+];
+
+let nextId = 4;
+
+function all() {
+  return notes;
+}
+
+function findById(id) {
+  return notes.find((n) => n.id === Number(id));
+}
+
+// Simulated SQL query. `whereClause` is a raw expression like "owner == 'alice'".
+// INTENTIONAL FLAW: the clause is evaluated directly, so a caller can inject
+// arbitrary expressions (e.g. "true || secret"). A real fix would use a
+// parameterized filter instead of evaluating untrusted strings.
+function query(whereClause) {
+  // eslint-disable-next-line no-new-func
+  const predicate = new Function('row', `with (row) { return (${whereClause}); }`);
+  return notes.filter((row) => {
+    try {
+      return predicate(row);
+    } catch {
+      return false;
+    }
+  });
+}
+
+function insert(note) {
+  const record = { id: nextId++, secret: false, ...note };
+  notes.push(record);
+  return record;
+}
+
+function remove(id) {
+  const before = notes.length;
+  notes = notes.filter((n) => n.id !== Number(id));
+  return notes.length < before;
+}
+
+function reset() {
+  notes = [
+    { id: 1, owner: 'alice', title: 'Buy milk', body: 'Whole milk, 2 liters', secret: false },
+    { id: 2, owner: 'alice', title: 'Launch plan', body: 'Ship the demo repo', secret: true },
+    { id: 3, owner: 'bob', title: 'Gym', body: 'Leg day', secret: false },
+  ];
+  nextId = 4;
+}
+
+module.exports = { all, findById, query, insert, remove, reset };