@delegance/claude-autopilot 5.2.2 → 6.2.2

package/dist/src/core/schema-alignment/extractor/prisma.js

@@ -1,18 +1,73 @@
-export function extractFromPrisma(content) {
-    const entities = [];
-    // Match model blocks: model Name { ... }
-    const modelRe = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
-    for (const modelMatch of content.matchAll(modelRe)) {
+const MODEL_RE = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
+const FIELD_RE = /^\s+(\w+)\s+\S/gm;
+function parseModels(content) {
+    const models = new Map();
+    for (const modelMatch of content.matchAll(MODEL_RE)) {
         const table = modelMatch[1];
-        entities.push({ table, operation: 'create_table' });
+        const fields = new Set();
         const body = modelMatch[2];
-        // Match field lines: fieldName TypeName ...
-        const fieldRe = /^\s+(\w+)\s+\S/gm;
-        for (const fieldMatch of body.matchAll(fieldRe)) {
+        for (const fieldMatch of body.matchAll(FIELD_RE)) {
             const column = fieldMatch[1];
             if (column.startsWith('@') || column === 'id')
                 continue;
-            entities.push({ table, column, operation: 'add_column' });
+            fields.add(column);
+        }
+        models.set(table, fields);
+    }
+    return models;
+}
+/**
+ * Extract schema entities from a Prisma schema file.
+ *
+ * When `previousContent` is provided, only the diff (added/removed fields,
+ * new/dropped tables) is emitted — this avoids over-reporting when a user
+ * touches schema.prisma for any reason (adding one field, editing a comment)
+ * and every long-existing field gets re-checked against type/API/UI layers.
+ *
+ * When `previousContent` is null/undefined, every model and field is emitted
+ * — the original "all entities are new" behavior used as a fallback when git
+ * history isn't available.
+ */
+export function extractFromPrisma(content, previousContent) {
+    const current = parseModels(content);
+    if (previousContent === undefined || previousContent === null) {
+        const entities = [];
+        for (const [table, fields] of current) {
+            entities.push({ table, operation: 'create_table' });
+            for (const column of fields)
+                entities.push({ table, column, operation: 'add_column' });
+        }
+        return entities;
+    }
+    const previous = parseModels(previousContent);
+    const entities = [];
+    for (const [table, currentFields] of current) {
+        const previousFields = previous.get(table);
+        if (!previousFields) {
+            // New table — emit create_table + add_column for every field
+            entities.push({ table, operation: 'create_table' });
+            for (const column of currentFields)
+                entities.push({ table, column, operation: 'add_column' });
+            continue;
+        }
+        for (const column of currentFields) {
+            if (!previousFields.has(column))
+                entities.push({ table, column, operation: 'add_column' });
+        }
+        for (const column of previousFields) {
+            if (!currentFields.has(column))
+                entities.push({ table, column, operation: 'drop_column' });
+        }
+    }
+    // Second pass — entirely dropped models. The first loop only iterates
+    // `current`, so a model present in `previous` but removed from `current`
+    // would never emit any entity, leaving stale references in type/API/UI
+    // layers undetected. Caught by Cursor Bugbot on PR #44 (MEDIUM).
+    for (const [table, previousFields] of previous) {
+        if (current.has(table))
+            continue;
+        for (const column of previousFields) {
+            entities.push({ table, column, operation: 'drop_column' });
         }
     }
     return entities;

package/dist/src/core/schema-alignment/git-history.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Read the previous version of a file from git, comparing against `base`.
+ * Returns null if the file has no git history at that ref (untracked,
+ * brand-new, not in a repo, or the ref doesn't resolve) — callers should
+ * fall back to whole-file extraction in that case.
+ *
+ * When `base` is omitted, the default is CI-aware (see `resolveDefaultBase`):
+ * - GitHub Actions PR build → `origin/<GITHUB_BASE_REF>`
+ * - GitLab MR build → `origin/<CI_MERGE_REQUEST_TARGET_BRANCH_NAME>`
+ * - everything else → `HEAD~1`
+ *
+ * Reading from `HEAD` directly is wrong in CI (any post-commit context):
+ * `HEAD` IS the current commit, so the diff against the working-tree file
+ * is always empty and no schema entities are emitted. Caught by Cursor
+ * Bugbot on PR #44 (HIGH); the multi-commit-PR variant of the same bug
+ * caught as a MEDIUM follow-up on the rebased commit.
+ */
+export declare function getPreviousFileContent(filePath: string, cwd?: string, base?: string): string | null;
+//# sourceMappingURL=git-history.d.ts.map

package/dist/src/core/schema-alignment/git-history.js

@@ -0,0 +1,53 @@
+import { spawnSync } from 'node:child_process';
+import * as path from 'node:path';
+/**
+ * Resolve the default base ref for git diffs in a CI-aware way.
+ *
+ * Priority: `GITHUB_BASE_REF` (GitHub Actions PR builds), then
+ * `CI_MERGE_REQUEST_TARGET_BRANCH_NAME` (GitLab MR builds), then `HEAD~1`
+ * for local / single-commit contexts. Branch-name env vars are prefixed
+ * with `origin/` so `git show <ref>:<file>` resolves to the
+ * remote-tracking-branch tip (the actual merge base).
+ *
+ * Caught + extended by Cursor Bugbot follow-up on PR #44 (MEDIUM): a static
+ * default of `HEAD~1` is wrong for multi-commit PRs — it points at the
+ * previous commit on the branch, not the merge base.
+ */
+function resolveDefaultBase() {
+    const ghBase = process.env.GITHUB_BASE_REF;
+    if (ghBase && ghBase.length > 0)
+        return `origin/${ghBase}`;
+    const glBase = process.env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME;
+    if (glBase && glBase.length > 0)
+        return `origin/${glBase}`;
+    return 'HEAD~1';
+}
+/**
+ * Read the previous version of a file from git, comparing against `base`.
+ * Returns null if the file has no git history at that ref (untracked,
+ * brand-new, not in a repo, or the ref doesn't resolve) — callers should
+ * fall back to whole-file extraction in that case.
+ *
+ * When `base` is omitted, the default is CI-aware (see `resolveDefaultBase`):
+ * - GitHub Actions PR build → `origin/<GITHUB_BASE_REF>`
+ * - GitLab MR build → `origin/<CI_MERGE_REQUEST_TARGET_BRANCH_NAME>`
+ * - everything else → `HEAD~1`
+ *
+ * Reading from `HEAD` directly is wrong in CI (any post-commit context):
+ * `HEAD` IS the current commit, so the diff against the working-tree file
+ * is always empty and no schema entities are emitted. Caught by Cursor
+ * Bugbot on PR #44 (HIGH); the multi-commit-PR variant of the same bug
+ * caught as a MEDIUM follow-up on the rebased commit.
+ */
+export function getPreviousFileContent(filePath, cwd = process.cwd(), base = resolveDefaultBase()) {
+    const relPath = path.isAbsolute(filePath) ? path.relative(cwd, filePath) : filePath;
+    const result = spawnSync('git', ['show', `${base}:${relPath}`], {
+        cwd,
+        encoding: 'utf8',
+        timeout: 5000,
+    });
+    if (result.status !== 0)
+        return null;
+    return result.stdout;
+}
+//# sourceMappingURL=git-history.js.map

package/dist/src/core/static-rules/rules/brand-tokens.js

@@ -36,8 +36,8 @@ function buildPalette(brandCfg, cwd) {
 export const brandTokensRule = {
     name: 'brand-tokens',
     severity: 'warning',
-    async check(touchedFiles, config = {}) {
-        const brandCfg = config.brand;
+    async check(touchedFiles, ctx = {}) {
+        const brandCfg = ctx.config?.brand;
         if (!brandCfg)
             return [];
         const cwd = process.cwd();

package/dist/src/core/static-rules/rules/schema-alignment.js

@@ -1,5 +1,6 @@
 import { detect } from "../../schema-alignment/detector.js";
 import { extract } from "../../schema-alignment/extractor/index.js";
+import { getPreviousFileContent } from "../../schema-alignment/git-history.js";
 import { scanLayers } from "../../schema-alignment/scanner.js";
 import { runLlmCheck } from "../../schema-alignment/llm-check.js";
 function isDestructive(entity) {
@@ -50,15 +51,24 @@ function structuralFinding(result, layer, defaultSev, sourceFile) {
 export const schemaAlignmentRule = {
     name: 'schema-alignment',
     severity: 'warning',
-    async check(touchedFiles, config = {}) {
-        const saConfig = config['schema-alignment'];
+    async check(touchedFiles, ctx = {}) {
+        const saConfig = ctx.config?.['schema-alignment'];
         if (saConfig?.enabled === false)
             return [];
         const cwd = process.cwd();
         const migrationFiles = detect(touchedFiles, saConfig);
         if (migrationFiles.length === 0)
             return [];
-        const allEntities = migrationFiles.flatMap(f => extract(f).map(entity => ({ entity, sourceFile: f })));
+        // For Prisma schema files, fetch the previous version from git so we only
+        // emit entities for what actually changed in this diff. SQL migrations
+        // are inherently a diff already; the SQL extractor ignores
+        // `previousContent`, so skipping the `git show` spawn there avoids pure
+        // waste (Bugbot LOW on PR #44).
+        const allEntities = migrationFiles.flatMap(f => {
+            const isPrisma = f.endsWith('.prisma');
+            const previousContent = isPrisma ? getPreviousFileContent(f, cwd) : null;
+            return extract(f, previousContent).map(entity => ({ entity, sourceFile: f }));
+        });
         if (allEntities.length === 0)
             return [];
         const scanResults = scanLayers(allEntities.map(e => e.entity), cwd, saConfig);
@@ -75,7 +85,7 @@ export const schemaAlignmentRule = {
             return [];
         const defaultSev = saConfig?.severity ?? 'warning';
         const llmEnabled = saConfig?.llmCheck !== false;
-        const engine = config['_engine'];
+        const engine = ctx.engine;
         // Structural mode — always compute these so we can fall back if LLM path yields nothing
         const structural = [];
         for (const { result: r, sourceFile } of gapResults) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delegance/claude-autopilot",
-  "version": "5.2.2",
+  "version": "6.2.2",
   "type": "module",
   "description": "Autonomous development pipeline for Claude Code: brainstorm → spec → plan → implement → migrate → validate → PR → review → merge. Multi-model, local-first, every phase a skill you can intervene in.",
   "keywords": [
@@ -52,24 +52,28 @@
   ],
   "scripts": {
     "test": "node scripts/test-runner.mjs",
+    "test:adapters:live": "node --test --import=tsx tests/adapters/live/vercel.cert.ts tests/adapters/live/fly.cert.ts tests/adapters/live/render.cert.ts",
     "typecheck": "tsc --noEmit",
     "build": "tsc -p tsconfig.build.json && node scripts/post-build-rewrite-imports.mjs",
     "prepublishOnly": "npm run build && npm test",
     "autoregress": "tsx scripts/autoregress.ts"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.91.1",
-    "@google/generative-ai": "^0.24.1",
-    "@modelcontextprotocol/sdk": "^1.29.0",
     "ajv": "^8",
+    "ajv-formats": "^3.0.1",
     "dotenv": ">=16",
     "js-yaml": "^4",
     "minimatch": ">=9",
-    "openai": ">=4",
     "proper-lockfile": "^4.1.2",
     "shell-quote": "^1.8.3",
     "tsx": ">=4"
   },
+  "optionalDependencies": {
+    "@anthropic-ai/sdk": "^0.91.1",
+    "@google/generative-ai": "^0.24.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "openai": ">=4"
+  },
   "devDependencies": {
     "@types/js-yaml": "^4",
     "@types/node": "^25",

package/scripts/autoregress.ts

@@ -6,7 +6,7 @@ import * as os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { selectSnapshots } from './snapshots/impact-selector.ts';
-import OpenAI from 'openai';
+import { loadOpenAI } from '../src/adapters/sdk-loader.ts';
 import { buildImportMap } from './snapshots/import-scanner.ts';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -230,6 +230,7 @@ async function cmdGenerate(args: string[]): Promise<number> {
 
   console.log(`[autoregress generate] generating snapshots for ${srcFiles.length} file(s)`);
 
+  const OpenAI = await loadOpenAI();
   const client = new OpenAI({ apiKey });
   let sourceCommit = 'unknown';
   try {
@@ -258,7 +259,7 @@ async function cmdGenerate(args: string[]): Promise<number> {
     let snapContent: string;
     try {
       const response = await client.responses.create({
-        model: process.env.CODEX_MODEL ?? 'gpt-5.3-codex',
+        model: process.env.CODEX_MODEL ?? 'gpt-5.5',
         instructions: 'You write TypeScript snapshot tests. Output ONLY the file contents, no markdown fences.',
         input: prompt,
         max_output_tokens: 2000,

package/skills/claude-autopilot.md

@@ -47,7 +47,7 @@ Each phase writes its output to disk. Claude can stop, the user can edit the art
    - PR review finds criticals → fix on branch, push, re-review (max 2 rounds).
    - Bugbot finds real bugs → fix, push, re-triage (max 3 rounds).
    - Unrecoverable failure → stop, report what completed, show what remains.
-4. **Codex review is part of the loop, not optional.** The pipeline explicitly dispatches to `gpt-5.3-codex` for spec review, plan review, and PR review. This is the multi-model moat — don't skip it.
+4. **Codex review is part of the loop, not optional.** The pipeline explicitly dispatches to `gpt-5.5` for spec review, plan review, and PR review. This is the multi-model moat — don't skip it.
 5. **Skills are swappable.** `review-2pass` and `council` are alternative review phases — a user can configure which runs. The pipeline doesn't hardcode Claude or Codex.
 
 ## Phase outputs

package/skills/make-interfaces-feel-better/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: make-interfaces-feel-better
+description: Craft-and-feel polish for an interface that already works correctly and is already simple. Use when the user says "feels off", "feels clunky", "not quite right", "doesn't feel polished", "lacks soul", "feels cheap", "add some life to it", "make it feel expensive", "feels like AI slop", or wants motion/typography/microcopy/color work that isn't about fixing bugs or alignment. This is the vibes layer — assumes correctness and subtraction are already handled. If the screen is broken or cluttered, route to /ui-ux-pro-max or /simplify-ui first. Complements frontend-design:frontend-design (creative vision) but is scoped to tuning what exists.
+---
+
+# Make interfaces feel better — the craft layer
+
+This skill is for the pass where the interface already *works* and is already *simple*, but still feels mediocre. You are tuning emotion, not structure. If the user hasn't had the basics fixed yet, recommend `/ui-ux-pro-max` and `/simplify-ui` first; great feel on top of a broken layout is lipstick.
+
+## The diagnostic
+
+Before touching anything, ask yourself what specific feeling is off. Interfaces usually fail one of five feels:
+
+1. **Cheap** — cramped, low-contrast, unbranded, no texture, inconsistent.
+2. **Cold / clinical** — correct but soulless. Efficient but no character.
+3. **Heavy / laggy** — transitions stutter, state changes snap, nothing feels alive.
+4. **Disorganized** — elements fight for attention; no clear visual hierarchy.
+5. **Nervous / fussy** — too many animations, too many chips, too many accent colors.
+
+The fix for each is different. Name the feeling first, then apply the matching lever below.
+
+## Levers — in order of impact-per-minute
+
+### 1. Typography (highest leverage)
+
+- **Pair a display face with a body face.** One distinctive (Playfair, Fraunces, Söhne, Tiempos, Inter Display) + one refined (Inter, Figtree, Söhne, IBM Plex, Geist). Don't use Inter for everything.
+- **Use the display only at top levels** — page title, card titles ≥ 18px. Everything else body.
+- **Tighten line-height on display** (1.1–1.2) and loosen on body (1.5–1.65).
+- **Letter-spacing for uppercase** — eyebrows and section labels get `letter-spacing: 0.05em` or more.
+- **One tabular-nums for numeric data** — `font-variant-numeric: tabular-nums` on any column of amounts makes them snap into alignment.
+
+### 2. Color & contrast
+
+- **One dominant color, one accent, one destructive. No fourth.**
+- **Backgrounds are off-white or off-black, never pure.** `#F7F8F6`, `#0B0D0A` — feel warmer than `#FFFFFF` / `#000000`.
+- **Shadows with color** — `box-shadow: 0 2px 12px rgba(brand-color, 0.08)` feels branded; `rgba(0,0,0,0.08)` feels generic.
+- **Gradients only on one element at a time.** Usually the primary CTA or the hero. Gradients everywhere = AI-slop.
+
+### 3. Motion
+
+- **Page-load stagger is cheap delight.** 40–80ms stagger on cards/rows hitting the viewport; nothing fancier.
+- **Easing: `cubic-bezier(0.22, 1, 0.36, 1)` for enter/exit.** Not `ease-in-out`.
+- **200–280ms for small transitions, 400–600ms for modals/layouts.** Outside that range feels wrong.
+- **Never animate what the user didn't cause.** Auto-pulsing "new" badges are hostile.
+- **Respect `prefers-reduced-motion`** — drop transitions to 0.01s, keep only opacity/color changes.
+
+### 4. Microcopy
+
+- **Button verbs specific to the action.** Not "Submit" — "Send quote for review."
+- **Empty states with personality.** "No quotes yet. Start one — it takes about 3 minutes." Beats "No data."
+- **Error messages that acknowledge** — "That's not quite right — X needs to be Y" rather than "Invalid input."
+- **Success states that celebrate proportionally.** Saved draft = small checkmark. Bound a policy = confetti-adjacent.
+- **Loading copy that sets expectations.** "Matching you with carriers… usually 5 seconds" > spinner alone.
+
+### 5. Texture & depth
+
+Not every interface needs these, but they're how screens stop feeling generic:
+- **Noise overlay at 2–4% opacity** on dark backgrounds. Kills the plastic look.
+- **Subtle inner shadow on inputs** — `inset 0 1px 0 rgba(255,255,255,0.4)` on light themes suggests depth.
+- **Asymmetric card padding** — e.g., `24px 24px 20px 24px` sometimes feels better than all-24 because humans scan top-to-bottom.
+- **Left-align eyebrow decoration** — a 2px × 18px accent-color rule before a section label reads as editorial, not chrome.
+
+### 6. The small details
+
+- **Focus rings that feel on-brand** — `box-shadow: 0 0 0 3px rgba(brand, 0.2)` beats the default blue browser ring.
+- **Checkmark animation on save** — 300ms stroke-dash reveal, not a static green dot.
+- **Hover states that change border color**, not scale or shadow (which feel toy-like on dense forms).
+- **Caret-color matched to brand.** `caret-color: var(--brand)`.
+- **Chip alignment with inline icons** — baseline-align the icon to the text, don't center — centering looks off for small text.
+
+## What to avoid (AI-slop tells)
+
+- Purple-to-pink gradients on white.
+- "Gradient text" for things that aren't hero titles.
+- Emoji in UI chrome (buttons, headers).
+- `font-family: 'Inter', sans-serif` as the only typeface.
+- Drop-shadows the same size on cards, buttons, and modals (varied elevation is the whole point).
+- Buttons with `border-radius: 9999px` that are 32px tall (pill at small scale reads as "claimed to be premium, actually built in 20 min").
+- Glass-morphism backdrops without a real background image behind them.
+
+## Workflow
+
+1. **Name the feel.** In one sentence, write what's wrong. "Feels cheap because inputs have no shadow and everything is pure white on pure white." This grounds the rest.
+2. **Apply at most 3 levers from the list above.** Do not touch everything — diminishing returns.
+3. **Reload and look away and back.** Judge fresh, not against your memory of before.
+4. **Name one thing you resisted adding.** This keeps you honest — feel upgrades are often about resisting maximalism, not piling it on.
+5. **Show the user which levers you pulled** and invite them to push back on any that felt wrong.
+
+## Red flags during the pass
+
+If you catch yourself adding:
+- A new color variable that isn't in the design system
+- A third weight of the display font
+- An animation > 600ms
+- A shadow on a default-state button
+- An emoji inside a form label
+
+…stop. You're adding where you should be tuning.
+
+## Interactions
+
+- Runs best on a screen that already passed `/ui-ux-pro-max` and `/simplify-ui`.
+- Can safely coexist with `/ui` for a combined sweep.
+- If the user wants a redesign, escalate to `frontend-design:frontend-design`.