agent-bober 0.1.0

package/templates/presets/react-vite/CLAUDE.md

@@ -0,0 +1,71 @@
+# Project Guide
+
+## Architecture
+
+This is a React + Express full-stack TypeScript application.
+
+```
+src/              React frontend (Vite)
+  App.tsx         Root component
+  main.tsx        Entry point
+  index.html      HTML template
+server/           Express backend
+  index.ts        Server entry point with API routes
+```
+
+**Frontend:** React 19, TypeScript, Vite 6, bundled with `@vitejs/plugin-react`.
+**Backend:** Express 5, TypeScript, running on Node with `tsx` in development.
+
+The Vite dev server proxies `/api/*` requests to the Express server at `localhost:3001`.
+
+## Running the Project
+
+```bash
+npm install               # install all dependencies
+npm run dev               # start both frontend (5173) and backend (3001)
+npm run dev:client        # start only the Vite dev server
+npm run dev:server        # start only the Express server
+```
+
+## Building
+
+```bash
+npm run build             # builds both client and server
+npm run build:client      # vite build -> dist/client/
+npm run build:server      # tsc -> dist/server/
+```
+
+## Testing
+
+```bash
+npm test                  # run unit tests with Vitest
+npm run test:watch        # run Vitest in watch mode
+npm run test:e2e          # run Playwright end-to-end tests
+```
+
+Unit tests live alongside source files as `*.test.ts` or `*.test.tsx`. Use `@testing-library/react` for component tests. Use `vitest` globals (`describe`, `it`, `expect`).
+
+## Linting and Type Checking
+
+```bash
+npm run lint              # ESLint across all .ts/.tsx files
+npm run typecheck         # tsc --noEmit for both client and server
+```
+
+## Coding Conventions
+
+- **TypeScript strict mode** is enabled everywhere. No `any` unless absolutely necessary.
+- **ESM only** (`"type": "module"` in package.json). Use `import`/`export`, never `require`.
+- **Functional React components** with hooks. No class components.
+- **Path aliases:** Use `@/` to import from `src/` in frontend code.
+- **API routes** are prefixed with `/api/`. All API responses are JSON.
+- **Error handling:** API endpoints must return appropriate HTTP status codes and structured error objects (`{ error: string, details?: unknown }`).
+- **No default exports** except for React page/route components and the Express app.
+- **File naming:** `kebab-case.ts` for utilities, `PascalCase.tsx` for React components.
+
+## Key Decisions
+
+- Vite is used instead of Next.js for simplicity and separation of concerns.
+- The backend is a standalone Express server, not a serverless function layer.
+- Vitest is used for unit tests (Vite-native, fast, compatible API).
+- Playwright handles E2E testing against the running application.

package/templates/presets/react-vite/bober.config.json

@@ -0,0 +1,53 @@
+{
+  "project": {
+    "name": "",
+    "mode": "greenfield",
+    "preset": "react-vite",
+    "description": "React + Vite frontend with Express backend"
+  },
+  "planner": {
+    "maxClarifications": 5,
+    "model": "opus",
+    "contextFiles": [
+      "package.json",
+      "tsconfig.json",
+      "vite.config.ts",
+      "server/index.ts"
+    ]
+  },
+  "generator": {
+    "model": "sonnet",
+    "maxTurnsPerSprint": 50,
+    "autoCommit": true,
+    "branchPattern": "bober/{feature-name}"
+  },
+  "evaluator": {
+    "model": "sonnet",
+    "strategies": [
+      { "type": "typecheck", "required": true },
+      { "type": "lint", "required": true },
+      { "type": "build", "required": true },
+      { "type": "unit-test", "required": true },
+      { "type": "playwright", "required": false }
+    ],
+    "maxIterations": 3
+  },
+  "sprint": {
+    "maxSprints": 10,
+    "requireContracts": true,
+    "sprintSize": "medium"
+  },
+  "pipeline": {
+    "maxIterations": 20,
+    "requireApproval": false,
+    "contextReset": "always"
+  },
+  "commands": {
+    "install": "npm install",
+    "build": "npm run build",
+    "test": "npm test",
+    "lint": "npm run lint",
+    "dev": "npm run dev",
+    "typecheck": "npx tsc --noEmit"
+  }
+}

package/templates/presets/react-vite/scaffold/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "concurrently \"npm run dev:client\" \"npm run dev:server\"",
+    "dev:client": "vite",
+    "dev:server": "tsx watch server/index.ts",
+    "build": "npm run build:client && npm run build:server",
+    "build:client": "vite build",
+    "build:server": "tsc -p server/tsconfig.json",
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:e2e": "playwright test",
+    "lint": "eslint . --ext .ts,.tsx",
+    "typecheck": "tsc --noEmit && tsc -p server/tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "express": "^5.0.1",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.19.0",
+    "@playwright/test": "^1.50.0",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.2.0",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.13.0",
+    "@types/react": "^19.0.8",
+    "@types/react-dom": "^19.0.3",
+    "@vitejs/plugin-react": "^4.3.4",
+    "concurrently": "^9.1.2",
+    "eslint": "^9.19.0",
+    "globals": "^15.14.0",
+    "jsdom": "^26.0.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.22.0",
+    "vite": "^6.0.11",
+    "vitest": "^3.0.5"
+  }
+}

package/templates/presets/react-vite/scaffold/server/index.ts

@@ -0,0 +1,38 @@
+import express from "express";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const app = express();
+const PORT = Number(process.env.PORT) || 3001;
+
+// -- Middleware ----------------------------------------------------------
+app.use(express.json());
+
+// -- API Routes ----------------------------------------------------------
+
+app.get("/api/health", (_req, res) => {
+  res.json({
+    status: "ok",
+    timestamp: new Date().toISOString(),
+  });
+});
+
+// -- Static Serving (production) -----------------------------------------
+// In production, serve the built Vite client from dist/client.
+if (process.env.NODE_ENV === "production") {
+  const clientDist = path.resolve(__dirname, "../client");
+  app.use(express.static(clientDist));
+
+  // SPA fallback: serve index.html for any non-API route.
+  app.get("*", (_req, res) => {
+    res.sendFile(path.join(clientDist, "index.html"));
+  });
+}
+
+// -- Start ---------------------------------------------------------------
+app.listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}`);
+});
+
+export default app;

package/templates/presets/react-vite/scaffold/server/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "../dist/server",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": true,
+    "isolatedModules": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/templates/presets/react-vite/scaffold/src/App.tsx

@@ -0,0 +1,37 @@
+import { useState, useEffect } from "react";
+
+interface HealthStatus {
+  status: string;
+  timestamp: string;
+}
+
+export default function App() {
+  const [health, setHealth] = useState<HealthStatus | null>(null);
+
+  useEffect(() => {
+    fetch("/api/health")
+      .then((res) => res.json())
+      .then((data: HealthStatus) => setHealth(data))
+      .catch(() => setHealth(null));
+  }, []);
+
+  return (
+    <main style={{ maxWidth: 640, margin: "0 auto", padding: "2rem" }}>
+      <h1>Welcome to Your App</h1>
+      <p>
+        Edit <code>src/App.tsx</code> to get started.
+      </p>
+      <section>
+        <h2>API Status</h2>
+        {health ? (
+          <p>
+            Server is <strong>{health.status}</strong> (checked at{" "}
+            {new Date(health.timestamp).toLocaleTimeString()})
+          </p>
+        ) : (
+          <p>Connecting to server...</p>
+        )}
+      </section>
+    </main>
+  );
+}

package/templates/presets/react-vite/scaffold/src/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>App</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/presets/react-vite/scaffold/src/main.tsx

@@ -0,0 +1,12 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import App from "./App.tsx";
+
+const rootEl = document.getElementById("root");
+if (!rootEl) throw new Error("Missing #root element in index.html");
+
+createRoot(rootEl).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);

package/templates/presets/react-vite/scaffold/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowImportingTsExtensions": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*", "vite-env.d.ts"],
+  "exclude": ["node_modules", "dist", "server"]
+}

package/templates/presets/react-vite/scaffold/vite.config.ts

@@ -0,0 +1,34 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import path from "node:path";
+
+export default defineConfig({
+  plugins: [react()],
+  root: "src",
+  publicDir: path.resolve(__dirname, "public"),
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "src"),
+    },
+  },
+  server: {
+    port: 5173,
+    proxy: {
+      "/api": {
+        target: "http://localhost:3001",
+        changeOrigin: true,
+      },
+    },
+  },
+  build: {
+    outDir: path.resolve(__dirname, "dist/client"),
+    emptyOutDir: true,
+    sourcemap: true,
+  },
+  test: {
+    globals: true,
+    environment: "jsdom",
+    setupFiles: [],
+    css: true,
+  },
+});

package/templates/presets/solidity/CLAUDE.md

@@ -0,0 +1,106 @@
+# Solidity Project Guide
+
+## Architecture
+
+This is an EVM smart contract project using Hardhat (or Foundry).
+
+```
+contracts/            Solidity source files
+  interfaces/         Interface definitions
+  libraries/          Shared library contracts
+test/                 Test files (Chai/Mocha for Hardhat, Forge tests for Foundry)
+scripts/              Deployment and utility scripts
+hardhat.config.ts     Hardhat configuration
+```
+
+## Hardhat Setup
+
+```bash
+npx hardhat compile           # compile all contracts
+npx hardhat test              # run the test suite
+npx hardhat test --grep "transfer"  # run tests matching a pattern
+npx hardhat node              # start a local Hardhat node
+npx hardhat run scripts/deploy.ts --network localhost  # deploy locally
+```
+
+If using Foundry alongside Hardhat:
+
+```bash
+forge build                   # compile with Foundry
+forge test                    # run Foundry tests
+forge test -vvv               # run with verbose output (traces)
+```
+
+## Contract Structure
+
+- Each contract goes in its own file under `contracts/`.
+- Use a consistent naming convention: `ContractName.sol` matches the contract name inside.
+- Inherit from OpenZeppelin contracts where possible instead of reimplementing standard functionality.
+- Define interfaces in `contracts/interfaces/` and implement them in concrete contracts.
+
+## OpenZeppelin Usage
+
+- Import OpenZeppelin contracts from `@openzeppelin/contracts`.
+- Common imports: `ERC20`, `ERC721`, `ERC1155`, `Ownable`, `AccessControl`, `ReentrancyGuard`, `Pausable`.
+- For upgradeable contracts, use `@openzeppelin/contracts-upgradeable` and initialize in an `initialize()` function instead of a constructor.
+
+## Testing
+
+- Write tests in TypeScript using Chai assertions and Mocha structure (`describe`, `it`).
+- Use `ethers.getSigners()` to get test accounts.
+- Use `loadFixture` from `@nomicfoundation/hardhat-toolbox` to snapshot and revert state between tests.
+- Test all success paths, revert conditions, event emissions, and edge cases.
+- Use `expect(...).to.be.revertedWith("message")` or `revertedWithCustomError` for revert testing.
+
+```typescript
+import { loadFixture } from "@nomicfoundation/hardhat-toolbox/network-helpers";
+import { expect } from "chai";
+import hre from "hardhat";
+
+describe("MyContract", function () {
+  async function deployFixture() {
+    const [owner, other] = await hre.ethers.getSigners();
+    const MyContract = await hre.ethers.getContractFactory("MyContract");
+    const contract = await MyContract.deploy();
+    return { contract, owner, other };
+  }
+
+  it("should do something", async function () {
+    const { contract, owner } = await loadFixture(deployFixture);
+    expect(await contract.owner()).to.equal(owner.address);
+  });
+});
+```
+
+## Deployment Scripts
+
+- Place deployment scripts in `scripts/`.
+- Use `hardhat-deploy` plugin or write custom scripts with `ethers`.
+- Always verify contracts on block explorers after deployment.
+
+## Gas Optimization
+
+- Use `uint256` instead of smaller uint types unless packing structs.
+- Prefer `calldata` over `memory` for external function parameters that are read-only.
+- Use `immutable` for variables set once in the constructor.
+- Use `constant` for compile-time constants.
+- Minimize storage writes (SSTORE is the most expensive opcode).
+- Use events for data that does not need on-chain reads.
+- Batch operations where possible to amortize base transaction costs.
+
+## Security Patterns
+
+- **Reentrancy**: Use `ReentrancyGuard` or follow checks-effects-interactions pattern.
+- **Overflow/Underflow**: Solidity 0.8+ has built-in overflow checks. Be careful with `unchecked` blocks.
+- **Access Control**: Use `Ownable` for simple ownership or `AccessControl` for role-based permissions.
+- **Input Validation**: Validate all external inputs with `require` statements at the top of functions.
+- **Frontrunning**: Consider commit-reveal schemes or use flashbots for sensitive transactions.
+- **Upgradability**: If using proxies, follow the UUPS or Transparent Proxy pattern. Never leave an implementation uninitialized.
+
+## Linting
+
+```bash
+npx solhint 'contracts/**/*.sol'    # lint Solidity files
+```
+
+Configure rules in `.solhint.json`. Recommended rules: `compiler-version`, `no-unused-vars`, `reason-string`, `func-visibility`.

package/templates/presets/solidity/bober.config.json

@@ -0,0 +1,9 @@
+{
+  "project": { "name": "my-contracts", "mode": "greenfield", "preset": "solidity" },
+  "evaluator": { "model": "sonnet", "strategies": [
+    { "type": "build", "required": true },
+    { "type": "lint", "required": true },
+    { "type": "unit-test", "required": true }
+  ], "maxIterations": 3 },
+  "commands": { "build": "npx hardhat compile", "test": "npx hardhat test", "lint": "npx solhint 'contracts/**/*.sol'" }
+}