analyzthis_design 1.20.1 → 2.0.1

package/dist/supabase/migrations/001_persona_feedback.sql

@@ -0,0 +1,54 @@
+-- Persona feedback — anonymous community corrections for analyzthis_design
+-- Run in Supabase SQL editor or via supabase db push
+
+create table if not exists public.persona_feedback (
+  id uuid primary key default gen_random_uuid(),
+  created_at timestamptz not null default now(),
+
+  install_id text not null,
+  package_version text,
+  feedback_id text,
+
+  persona text not null,
+  satisfied boolean not null default false,
+  rating smallint check (rating is null or (rating >= 1 and rating <= 5)),
+  tags text[] not null default '{}',
+
+  user_comment text,
+  assistant_rejected text,
+  assistant_preferred text,
+  task_summary text,
+  problem_type text,
+  mode text,
+  recorded_at timestamptz
+);
+
+create index if not exists persona_feedback_persona_idx on public.persona_feedback (persona);
+create index if not exists persona_feedback_created_at_idx on public.persona_feedback (created_at desc);
+create index if not exists persona_feedback_tags_idx on public.persona_feedback using gin (tags);
+
+alter table public.persona_feedback enable row level security;
+
+-- Anonymous clients may INSERT only (no read/update/delete for anon)
+drop policy if exists "anon_insert_persona_feedback" on public.persona_feedback;
+create policy "anon_insert_persona_feedback"
+  on public.persona_feedback
+  for insert
+  to anon
+  with check (
+    char_length(coalesce(user_comment, '')) <= 2000
+    and char_length(coalesce(assistant_rejected, '')) <= 4000
+    and char_length(coalesce(assistant_preferred, '')) <= 4000
+    and persona ~ '^[a-z][a-z0-9_-]{0,31}$'
+  );
+
+-- Service role (dashboard) can read everything — use Supabase dashboard or service key
+drop policy if exists "service_read_persona_feedback" on public.persona_feedback;
+create policy "service_read_persona_feedback"
+  on public.persona_feedback
+  for select
+  to service_role
+  using (true);
+
+comment on table public.persona_feedback is
+  'Anonymous opt-in persona correction data from analyzthis_design CLI (feedback submit).';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "analyzthis_design",
-  "version": "1.20.1",
-  "description": "8 AI design personas — adversarial deliberation loops, opt-in community feedback, Kavi knowledge collection, DesignSpec producer path, wireframe skills, UX critique, Agent Skills for Cursor, Claude, Codex, Grok, Windsurf.",
+  "version": "2.0.1",
+  "description": "8 AI design personas — v2.0 chunked execution with frontier planner + free/cheap chunk models, adversarial deliberation loops, opt-in community feedback, Kavi knowledge collection, DesignSpec producer path, wireframe skills, UX critique, Agent Skills for Cursor, Claude, Codex, Grok, Windsurf.",
   "keywords": [
     "cursor",
     "cursor-skill",
@@ -35,11 +35,14 @@
     "agents/",
     "supabase/",
     ".github/",
-    "README.md"
+    "scripts/validate-csvs.js",
+    "README.md",
+    "HOW-TO-USE.md"
   ],
   "scripts": {
     "build": "node scripts/obfuscate.js",
-    "prepublishOnly": "npm run build",
+    "validate": "node scripts/validate-csvs.js",
+    "prepublishOnly": "npm run build && npm run validate",
     "postinstall": "node dist/lib/install.js --silent --welcome"
   },
   "engines": {

package/scripts/validate-csvs.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * CSV validation script.
+ *
+ * Checks every CSV file in skills/design-reference/ against schema.json:
+ *   1. Row cell count matches header column count
+ *   2. No column has a No column missing
+ *   3. Cross-file joins resolve (e.g. products.csv Mapped Pattern → landing.csv Pattern Name)
+ *   4. Filter columns are populated (not empty for majority of rows)
+ *
+ * Usage: node scripts/validate-csvs.js
+ * Exit code: 0 = all pass, 1 = errors found
+ */
+
+var fs = require('fs');
+var path = require('path');
+var retrieve = require('../lib/retrieve');
+
+var REF_DIR = path.join(__dirname, '..', 'skills', 'design-reference');
+var SCHEMA_PATH = path.join(REF_DIR, 'schema.json');
+
+function parseCsvLine(line) {
+  var cells = [];
+  var cur = '';
+  var inQuotes = false;
+  for (var i = 0; i < line.length; i++) {
+    var ch = line[i];
+    if (inQuotes) {
+      if (ch === '"' && line[i + 1] === '"') { cur += '"'; i++; }
+      else if (ch === '"') { inQuotes = false; }
+      else { cur += ch; }
+    } else if (ch === '"') { inQuotes = true; }
+    else if (ch === ',') { cells.push(cur); cur = ''; }
+    else { cur += ch; }
+  }
+  cells.push(cur);
+  return cells;
+}
+
+function splitCsvRows(text) {
+  var rows = [];
+  var cur = '';
+  var inQuotes = false;
+  for (var i = 0; i < text.length; i++) {
+    var ch = text[i];
+    if (ch === '"') inQuotes = !inQuotes;
+    if (ch === '\n' && !inQuotes) { rows.push(cur); cur = ''; }
+    else if (ch !== '\r') cur += ch;
+  }
+  if (cur.trim().length) rows.push(cur);
+  return rows;
+}
+
+var schema = JSON.parse(fs.readFileSync(SCHEMA_PATH, 'utf8'));
+var errors = [];
+var warnings = [];
+
+for (var fileKey in schema.files) {
+  var spec = schema.files[fileKey];
+  var filePath = path.join(REF_DIR, fileKey);
+  if (!fs.existsSync(filePath)) {
+    errors.push(fileKey + ': FILE MISSING');
+    continue;
+  }
+
+  var content = fs.readFileSync(filePath, 'utf8');
+  var rows = splitCsvRows(content);
+  var header = parseCsvLine(rows[0]);
+  var expectedHeader = spec.header;
+
+  // Check header matches schema
+  if (header.length !== expectedHeader.length) {
+    errors.push(fileKey + ': header has ' + header.length + ' columns, schema expects ' + expectedHeader.length);
+  } else {
+    for (var h = 0; h < header.length; h++) {
+      if (header[h].trim() !== expectedHeader[h].trim()) {
+        errors.push(fileKey + ': header column ' + h + ' is "' + header[h].trim() + '", schema expects "' + expectedHeader[h].trim() + '"');
+      }
+    }
+  }
+
+  // Check each data row has the right cell count
+  var badRows = 0;
+  for (var r = 1; r < rows.length; r++) {
+    if (!rows[r].trim()) continue;
+    var cells = parseCsvLine(rows[r]);
+    if (cells.length !== header.length) {
+      badRows++;
+      if (badRows <= 3) {
+        errors.push(fileKey + ' row ' + (r + 1) + ': ' + cells.length + ' cells (expected ' + header.length + ')');
+      }
+    }
+  }
+  if (badRows > 3) {
+    errors.push(fileKey + ': ... and ' + (badRows - 3) + ' more row-length mismatches');
+  }
+
+  // Check No column exists
+  if (spec.no_column && header.indexOf(spec.no_column) === -1) {
+    errors.push(fileKey + ': missing No column "' + spec.no_column + '"');
+  }
+
+  // Check filter column is populated
+  if (spec.filter_column) {
+    var filterIdx = header.indexOf(spec.filter_column);
+    if (filterIdx === -1) {
+      errors.push(fileKey + ': filter column "' + spec.filter_column + '" not found in header');
+    } else {
+      var emptyCount = 0;
+      var totalRows = 0;
+      for (var r2 = 1; r2 < rows.length; r2++) {
+        if (!rows[r2].trim()) continue;
+        totalRows++;
+        var cells2 = parseCsvLine(rows[r2]);
+        if (!cells2[filterIdx] || !cells2[filterIdx].trim()) emptyCount++;
+      }
+      if (totalRows > 0 && emptyCount / totalRows > 0.3) {
+        warnings.push(fileKey + ': filter column "' + spec.filter_column + '" is empty in ' + emptyCount + '/' + totalRows + ' rows (' + Math.round(emptyCount / totalRows * 100) + '%)');
+      }
+    }
+  }
+
+  // Check cross-file joins
+  if (spec.joins) {
+    for (var joinCol in spec.joins) {
+      var joinSpec = spec.joins[joinCol];
+      var joinIdx = header.indexOf(joinCol);
+      if (joinIdx === -1) continue;
+
+      var targetPath = path.join(REF_DIR, joinSpec.target_file);
+      if (!fs.existsSync(targetPath)) continue;
+      var targetContent = fs.readFileSync(targetPath, 'utf8');
+      var targetRows = splitCsvRows(targetContent);
+      var targetHeader = parseCsvLine(targetRows[0]);
+      var targetColIdx = targetHeader.indexOf(joinSpec.target_column);
+      if (targetColIdx === -1) continue;
+
+      var targetValues = {};
+      for (var tr = 1; tr < targetRows.length; tr++) {
+        if (!targetRows[tr].trim()) continue;
+        var targetCells = parseCsvLine(targetRows[tr]);
+        var val = targetCells[targetColIdx];
+        if (val) targetValues[val] = true;
+      }
+
+      var joinMisses = 0;
+      var joinTotal = 0;
+      for (var jr = 1; jr < rows.length; jr++) {
+        if (!rows[jr].trim()) continue;
+        var joinCells = parseCsvLine(rows[jr]);
+        var joinVal = joinCells[joinIdx];
+        if (!joinVal || !joinVal.trim()) continue;
+        joinTotal++;
+        if (!targetValues[joinVal]) joinMisses++;
+      }
+      if (joinTotal > 0 && joinMisses / joinTotal > 0.2) {
+        warnings.push(fileKey + ': join "' + joinCol + '" → ' + joinSpec.target_file + '.' + joinSpec.target_column + ': ' + joinMisses + '/' + joinTotal + ' misses (' + Math.round(joinMisses / joinTotal * 100) + '%)');
+      }
+    }
+  }
+
+  // Check Docs URL sparseness in stack files
+  if (fileKey.indexOf('stacks/') === 0) {
+    var docsIdx = header.indexOf('Docs URL');
+    if (docsIdx !== -1) {
+      var emptyDocs = 0;
+      var totalStack = 0;
+      for (var dr = 1; dr < rows.length; dr++) {
+        if (!rows[dr].trim()) continue;
+        totalStack++;
+        var docsCells = parseCsvLine(rows[dr]);
+        if (!docsCells[docsIdx] || !docsCells[docsIdx].trim()) emptyDocs++;
+      }
+      if (totalStack > 0 && emptyDocs / totalStack > 0.5) {
+        warnings.push(fileKey + ': Docs URL empty in ' + emptyDocs + '/' + totalStack + ' rows');
+      }
+    }
+  }
+}
+
+// Report
+if (warnings.length) {
+  console.log('\n── Warnings ──');
+  warnings.forEach(function(w) { console.log('  ⚠ ' + w); });
+}
+
+if (errors.length) {
+  console.log('\n── Errors ──');
+  errors.forEach(function(e) { console.log('  ✗ ' + e); });
+  console.log('\n❌ ' + errors.length + ' error(s), ' + warnings.length + ' warning(s)\n');
+  process.exit(1);
+} else {
+  console.log('\n✅ All ' + Object.keys(schema.files).length + ' CSV files pass validation (' + warnings.length + ' warning(s))\n');
+  process.exit(0);
+}

package/skills/chunk-planner/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: chunk-planner
+description: Explain the chunked execution planner. The planner is a frontier/strong model that breaks a design task into small, sequential chunks and assigns each to the cheapest capable model.
+---
+
+# Chunk Planner
+
+In Analyzthis Design v2.0, the default `run` command uses **chunked execution**.
+
+## How it works
+
+1. **Planner** (frontier/strong model) reads the task + knowledge bank once.
+2. It produces a chunk graph: persona, goal, prompts, effort, and dependencies per chunk.
+3. **Router** picks the cheapest capable model for each chunk from:
+   - Local Ollama models (auto-detected)
+   - Free cloud APIs (Groq, Google Gemini, OpenRouter)
+   - Cheap cloud APIs (OpenAI GPT-4o-mini, DeepSeek, Together)
+4. **Executor** runs chunks sequentially by default, with retry + fallback.
+5. **Synthesis** merges outputs and produces a final verdict.
+
+## Planner policy
+
+- The planner **never** runs on a lower/cheap model.
+- If no frontier API key is available, it falls back to the host/Devi model with a warning.
+
+## Example plan
+
+```json
+{
+  "chunks": [
+    { "id": "ia", "persona": "noor", "effort": "standard", "depends_on": [] },
+    { "id": "visual", "persona": "arjun", "effort": "standard", "depends_on": ["ia"] },
+    { "id": "feasibility", "persona": "priya", "effort": "trivial", "depends_on": ["ia"] },
+    { "id": "synthesis", "persona": "raj", "effort": "hard", "depends_on": ["visual", "feasibility"] }
+  ]
+}
+```
+
+## Inspect a plan without running it
+
+```bash
+npx analyzthis_design run --task "..." --dry-run
+```
+
+This shows the planner output without calling any chunk models.