analyzthis_design 2.1.2 → 2.3.0

package/dist/lib/chunk-synthesis.js

@@ -29,18 +29,46 @@ function buildSynthesisPrompt(plan, results, contextPack) {
     lines.push(r.output.slice(0, 1200));
   }
 
+  // Detect disagreements between personas for explicit arbitration.
+  var disagreements = [];
+  for (var a = 0; a < results.length; a++) {
+    for (var b = a + 1; b < results.length; b++) {
+      var va = results[a].structured_output && results[a].structured_output.verdict;
+      var vb = results[b].structured_output && results[b].structured_output.verdict;
+      if (va && vb && va !== vb) {
+        disagreements.push(results[a].persona + ' says ' + va + ' but ' + results[b].persona + ' says ' + vb);
+      }
+    }
+  }
+
   lines.push('',
+    'You MUST do the following:',
+    '',
+    '1. RESOLVE CONFLICTS: If personas disagree on any point, pick a winner. Do not present both sides and leave it open. State which persona is correct and why, with a forward path.',
+    '2. CHALLENGE THE PREMISE: Before accepting the task framing, ask: "Are we solving the right problem?" If the premise is questionable, flag it explicitly.',
+    '3. Give a definitive answer — not a summary of opinions.',
+    '',
     'Produce:',
+    '- Premise check: Is the task framing valid? If not, what is the real problem?',
+    '- Resolved conflicts: For each disagreement, who is right and why.',
     '- Verdict: SHIP | REVISE | BLOCK',
     '- Composite score out of 5 if applicable',
-    '- Top 3 actionable changes',
+    '- Top 3 actionable changes (each with a specific forward path, not just "fix it")',
     '- Brief reasoning',
     '',
     'Use the same format as the design-critic synthesis.'
   );
 
+  if (disagreements.length) {
+    lines.splice(lines.indexOf('You MUST do the following:'), 0,
+      'DETECTED DISAGREEMENTS (must resolve each):', '');
+    for (var d = 0; d < disagreements.length; d++) {
+      lines.splice(lines.indexOf('DETECTED DISAGREEMENTS'), 0, '  - ' + disagreements[d]);
+    }
+  }
+
   return {
-    system: 'You synthesize multi-persona design critique outputs. Be concise and cite the most important conflicts.',
+    system: 'You synthesize multi-persona design critique outputs. You are decisive — not a summarizer. Resolve conflicts explicitly, challenge premises, and give forward paths. If personas contradict, pick a winner with reasoning.',
     user: lines.join('\n'),
   };
 }
@@ -138,6 +166,9 @@ async function synthesize(opts) {
     markdown: syn.markdown || text,
     model_used: { provider: model.provider, model: model.model, cost: model.cost },
     contradictions: contradictions,
+    premise_challenge: extractPremiseCheck(text),
+    conflict_resolutions: extractConflictResolutions(text),
+    raw_synthesis: text,
     tokens: { input: inTok, output: outTok },
     cost: chunkModels.estimateCost(model, inTok, outTok),
   };
@@ -169,8 +200,34 @@ function fallbackSynthesis(results) {
   };
 }
 
+function extractPremiseCheck(text) {
+  if (!text) return null;
+  var m = text.match(/premise[\s:]*check[\s:]*([^\n]+)/i);
+  if (m) return m[1].trim();
+  m = text.match(/are we solving[\s\S]{0,200}/i);
+  if (m) return m[0].trim();
+  m = text.match(/premise[\s:]*([valid|questionable|invalid]+)/i);
+  if (m) return m[0].trim();
+  return null;
+}
+
+function extractConflictResolutions(text) {
+  if (!text) return [];
+  var resolutions = [];
+  var blocks = text.split(/\n(?=\d+\.|resolve|conflict|disagree)/i);
+  for (var i = 0; i < blocks.length; i++) {
+    var b = blocks[i].trim();
+    if (/^(resolve|conflict|disagree)/i.test(b) || /^\d+\.\s*(resolve|conflict)/i.test(b)) {
+      resolutions.push(b.slice(0, 300));
+    }
+  }
+  return resolutions;
+}
+
 module.exports = {
   synthesize: synthesize,
   buildSynthesisPrompt: buildSynthesisPrompt,
   hasContradictions: hasContradictions,
+  extractPremiseCheck: extractPremiseCheck,
+  extractConflictResolutions: extractConflictResolutions,
 };

package/dist/lib/collect.js

@@ -767,22 +767,26 @@ async function collect(opts = {}) {
     }
   }
 
-  // Auto-connect discovered sources + Kavi vault, then sync knowledge bank
-  console.log(`\n⏳ Wiring knowledge bank...`);
+  // Auto-connect discovered sources + Kavi vault, then sync knowledge bank.
+  // Scoped to the current project so this project's vault never bleeds into
+  // another project's knowledge bank (the v2.2 project-scoping fix).
+  console.log(`\n⏳ Wiring knowledge bank (project: ${projectId})...`);
   const connectResult = discoverSources
     ? connectDiscoveredSources({
       discoveries: sourceDiscoveries,
       kaviVaultPath: vaultPath,
       config,
       autoConnect: config.collect?.auto_connect_discovered !== false,
+      project: projectId,
+      cwd,
     })
     : { connected: [], skipped: [] };
   if (connectResult.connected.length > 0) {
     console.log(`   Auto-connected ${connectResult.connected.length} source(s):`);
     for (const p of connectResult.connected) console.log(`   • ${p}`);
   }
-  knowledge.connect({ vaultPath, tags: [], include: [] });
-  const syncResult = knowledge.sync({ targets });
+  knowledge.connect({ vaultPath, tags: [], include: [], project: projectId, cwd });
+  const syncResult = knowledge.sync({ targets, project: projectId, cwd });
   cache.invalidatePrefix('kb:');
 
   if (syncResult.message) {

package/dist/lib/install.js

@@ -227,6 +227,17 @@ function install({ silent = false, force = false, target = 'cursor', showBanner
     if (showBanner && !silent && (installed.length > 0 || skipped.length > 0)) {
       printWelcomeBanner(tId, log);
     }
+
+    // Auto-configure MCP server for supported hosts.
+    if (tId === 'cursor' || tId === 'claude' || tId === 'windsurf') {
+      try {
+        const mcpServer = require('./mcp-server');
+        mcpServer.writeMcpConfig(tId);
+        log('  MCP server configured. Restart ' + t.label + ' to activate.\n');
+      } catch (e) {
+        // MCP config is best-effort — don't fail install if it doesn't work.
+      }
+    }
   }
 }
 

package/dist/lib/knowledge.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 'use strict';
 
-const fs   = require('fs');
-const path = require('path');
-const os   = require('os');
+const fs     = require('fs');
+const path   = require('path');
+const os     = require('os');
+const crypto = require('crypto');
 
 const CONFIG_DIR        = path.join(os.homedir(), '.analyzthis_design');
 const CONFIG_FILE       = path.join(CONFIG_DIR, 'config.json');
@@ -32,9 +33,14 @@ const CATEGORIES = {
 // ─── Config helpers ──────────────────────────────────────────────────────────
 
 function loadConfig() {
-  if (!fs.existsSync(CONFIG_FILE)) return { sources: [] };
-  try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); }
-  catch { return { sources: [] }; }
+  if (!fs.existsSync(CONFIG_FILE)) return { sources: [], projects: {} };
+  try {
+    const cfg = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    if (!cfg.sources) cfg.sources = [];
+    if (!cfg.projects) cfg.projects = {};
+    return cfg;
+  }
+  catch { return { sources: [], projects: {} }; }
 }
 
 function saveConfig(config) {
@@ -42,6 +48,79 @@ function saveConfig(config) {
   fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
 
+// ─── Project scoping ─────────────────────────────────────────────────────────
+// Knowledge sources are scoped per project by default. Each project's sources
+// live under config.projects[projectId].sources and the master knowledge-bank
+// is written into that project's local skills directory (e.g.
+// <projectRoot>/.claude/skills/knowledge-bank/SKILL.md), so invoking a skill
+// from one project never reads another project's vaults.
+//
+// Pass { global: true } (or --global on the CLI) to opt into the legacy merged
+// behavior: read config.sources and write into ~/.claude/skills/... This is the
+// only path that ever blends multiple projects' notes together.
+
+function resolveProjectScope({ project, global, cwd } = {}) {
+  // Explicit --global wins: read the legacy merged pool, write to global skills dirs.
+  if (global) return { scope: 'global', projectId: null, projectRoot: null };
+
+  // --project <id> (or a caller-provided project id): use that id, rooted at cwd.
+  let projectId = project;
+  let projectRoot = path.resolve(cwd || process.cwd());
+
+  // Default: auto-derive a project id from cwd, the same way session.js does.
+  if (!projectId) {
+    const abs = path.resolve(cwd || process.cwd());
+    const slug = path.basename(abs).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'project';
+    const hash = crypto.createHash('sha1').update(abs).digest('hex').slice(0, 8);
+    projectId = `${slug}-${hash}`;
+  }
+
+  return { scope: 'project', projectId, projectRoot };
+}
+
+// Return the sources array for a resolved scope, creating the project entry
+// on first use. For global scope, returns the legacy top-level config.sources.
+function scopedSources(config, scopeInfo, { create = false } = {}) {
+  if (scopeInfo.scope === 'global') return config.sources;
+  if (!config.projects[scopeInfo.projectId] && create) {
+    config.projects[scopeInfo.projectId] = { sources: [], addedAt: new Date().toISOString() };
+  }
+  const proj = config.projects[scopeInfo.projectId];
+  return proj ? proj.sources : null;
+}
+
+// Per-tool skill roots, expressed relative to a project root, mirroring the
+// global TARGETS layout in platforms.js. Used when writing project-local
+// knowledge-bank files so each project's skills load only inside that project.
+const PROJECT_REL_TARGETS = [
+  { id: 'cursor',   rel: ['.cursor', 'skills'],                       layout: 'dir'  },
+  { id: 'claude',   rel: ['.claude', 'skills'],                        layout: 'dir'  },
+  { id: 'claude-cmds', rel: ['.claude', 'commands'],                  layout: 'flat' },
+  { id: 'codex',    rel: ['.codex', 'skills'],                        layout: 'dir'  },
+  { id: 'grok',     rel: ['.grok', 'skills'],                         layout: 'dir'  },
+  { id: 'windsurf', rel: ['.codeium', 'windsurf', 'skills'],          layout: 'dir'  },
+  { id: 'agents',   rel: ['.agents', 'skills'],                       layout: 'dir'  },
+];
+
+function projectTargets(projectRoot, requestedTargets) {
+  // requestedTargets is the resolved list from resolveTargets (e.g. ['cursor'],
+  // ['claude'], or ALL_TARGET_IDS). claude-cmds is always paired with claude.
+  const want = new Set(requestedTargets);
+  const out = [];
+  for (const t of PROJECT_REL_TARGETS) {
+    if (t.id === 'claude-cmds') {
+      if (want.has('claude')) out.push(t);
+    } else if (want.has(t.id)) {
+      out.push(t);
+    }
+  }
+  return out.map((t) => ({
+    id: t.id,
+    root: path.join(projectRoot, ...t.rel),
+    layout: t.layout,
+  }));
+}
+
 // ─── Vault reading ───────────────────────────────────────────────────────────
 
 // Recursively collect all .md files under a directory
@@ -103,29 +182,54 @@ function categorize(title, tags, body) {
 
 /**
  * Register a vault or folder as a knowledge source.
+ *
+ * By default the source is scoped to the project derived from cwd, so it only
+ * feeds critiques run from that project. Pass { global: true } to register it
+ * in the legacy merged pool (config.sources) instead.
+ *
  * Options:
  *   include  — array of sub-folder prefixes to include, e.g. ['Design', 'Brand']
  *   tags     — array of tags to filter by, e.g. ['ux', 'design', 'brand']
+ *   project  — explicit project id (overrides cwd-derived id)
+ *   global   — when true, register in the legacy merged pool instead
+ *   cwd      — working directory used to derive the project id (default: process.cwd())
  */
-function connect({ vaultPath, include = [], tags = [] }) {
+function connect({ vaultPath, include = [], tags = [], project, global = false, cwd } = {}) {
   const abs = path.resolve(vaultPath);
   if (!fs.existsSync(abs)) throw new Error(`Path does not exist: ${abs}`);
 
   const config = loadConfig();
-  // Replace any existing entry with the same path
-  config.sources = config.sources.filter(s => s.path !== abs);
-  config.sources.push({ path: abs, include, tags, addedAt: new Date().toISOString() });
+  const scopeInfo = resolveProjectScope({ project, global, cwd });
+  const sources = scopedSources(config, scopeInfo, { create: true });
+  // Replace any existing entry with the same path within this scope
+  const filtered = sources.filter(s => s.path !== abs);
+  filtered.push({ path: abs, include, tags, addedAt: new Date().toISOString() });
+  if (scopeInfo.scope === 'global') {
+    config.sources = filtered;
+  } else {
+    config.projects[scopeInfo.projectId].sources = filtered;
+  }
   saveConfig(config);
   return abs;
 }
 
 /**
  * Remove a vault/folder from the knowledge sources list.
+ * Accepts the same { project, global, cwd } options as connect() to target
+ * the right scope.
  */
-function disconnect(vaultPath) {
+function disconnect(vaultPath, opts = {}) {
   const abs = path.resolve(vaultPath);
   const config = loadConfig();
-  config.sources = config.sources.filter(s => s.path !== abs);
+  const scopeInfo = resolveProjectScope(opts);
+  const sources = scopedSources(config, scopeInfo);
+  if (!sources) return; // nothing in this scope yet
+  const filtered = sources.filter(s => s.path !== abs);
+  if (scopeInfo.scope === 'global') {
+    config.sources = filtered;
+  } else if (config.projects[scopeInfo.projectId]) {
+    config.projects[scopeInfo.projectId].sources = filtered;
+  }
   saveConfig(config);
 }
 
@@ -133,19 +237,38 @@ function disconnect(vaultPath) {
  * Read all connected sources, filter notes, build knowledge-bank.md,
  * and copy it to all requested target AI tool directories.
  *
- * targets — array of tool names: 'cursor', 'claude', 'codex'
+ * By default the bank is scoped to the project derived from cwd: it reads
+ * only that project's sources and writes into that project's local skills
+ * directory (<projectRoot>/.claude/skills/knowledge-bank/SKILL.md, etc.), so
+ * invoking a skill from one project never pulls in another project's vaults.
+ *
+ * Pass { global: true } (or --global) to opt into the legacy merged behavior:
+ * read config.sources and write into ~/.claude/skills/... so multiple
+ * projects' notes blend together. Use this only when you deliberately want
+ * cross-project blending.
+ *
+ * targets — array of tool names: 'cursor', 'claude', 'codex', 'grok',
+ *           'windsurf', 'agents', or ['all']
+ * project — explicit project id (overrides cwd-derived id)
+ * global   — when true, use the legacy merged pool
+ * cwd      — working directory used to derive the project id
  */
-function sync({ targets = ['cursor'] } = {}) {
+function sync({ targets = ['cursor'], project, global = false, cwd } = {}) {
   const config = loadConfig();
-
-  if (!config.sources || config.sources.length === 0) {
-    return { synced: 0, message: 'No sources connected. Run: npx analyzthis_design connect --vault /path/to/vault' };
+  const scopeInfo = resolveProjectScope({ project, global, cwd });
+  const sources = scopedSources(config, scopeInfo) || [];
+
+  if (!sources || sources.length === 0) {
+    const hint = scopeInfo.scope === 'global'
+      ? 'No sources connected. Run: npx analyzthis_design connect --vault /path/to/vault --global'
+      : `No sources connected for project "${scopeInfo.projectId}". Run: npx analyzthis_design collect (from inside the project) or npx analyzthis_design connect --vault /path/to/vault`;
+    return { synced: 0, message: hint };
   }
 
   const sections = { prd: [], brand: [], product: [], design: [], research: [], tech: [], web: [], other: [] };
   let totalFiles = 0;
 
-  for (const source of config.sources) {
+  for (const source of sources) {
     const files = readMarkdownFiles(source.path);
 
     for (const filePath of files) {
@@ -184,7 +307,7 @@ function sync({ targets = ['cursor'] } = {}) {
   } catch { /* no session / research available — fine */ }
 
   // Build the knowledge-bank markdown
-  const sourceList = config.sources.map(s => s.path).join(', ');
+  const sourceList = sources.map(s => s.path).join(', ');
   const date       = new Date().toISOString().split('T')[0];
 
   // PRD/stories listed first — ux-story-gate reads this section in Phase 0
@@ -199,6 +322,10 @@ function sync({ targets = ['cursor'] } = {}) {
     { key: 'other',    heading: '## Additional Context' },
   ];
 
+  const scopeLabel = scopeInfo.scope === 'global'
+    ? 'global (merged across projects)'
+    : `project: ${scopeInfo.projectId}`;
+
   let md = `---
 name: knowledge-bank
 description: Personal knowledge bank — takes precedence over all built-in persona defaults.
@@ -208,6 +335,7 @@ disable-model-invocation: true
 # Knowledge Bank
 
 > Last synced: ${date}
+> Scope: ${scopeLabel}
 > Sources: ${sourceList}
 > Files loaded: ${totalFiles}
 
@@ -232,53 +360,63 @@ disable-model-invocation: true
     md += `_No matching files found. Check your --tags or --include filters, or remove filters to include all notes._\n`;
   }
 
-  // Write to the package's own skills/knowledge-bank/SKILL.md
+  // Write to the package's own skills/knowledge-bank/SKILL.md (source of truth)
   fs.mkdirSync(path.dirname(KNOWLEDGE_SKILL), { recursive: true });
   fs.writeFileSync(KNOWLEDGE_SKILL, md);
 
   // Build per-persona knowledge slices (priority + fallback)
   try {
     const session = require('./session');
-    const projectId = session.getProjectId();
+    const projectId = scopeInfo.scope === 'project' ? scopeInfo.projectId : session.getProjectId();
     writePersonaSlices(sections, sectionDefs, projectId);
   } catch {
     // sessions unavailable — skip slices
   }
 
-  // Copy knowledge-bank into every requested platform (dir and/or flat layout)
+  // Copy knowledge-bank into every requested platform.
+  // Project-scoped → write into <projectRoot>/.{tool}/skills/... (project-local,
+  //   loaded only when the skill is invoked from inside that project).
+  // Global-scoped → write into ~/.{tool}/skills/... (legacy merged behavior).
   const { TARGETS, resolveTargets } = require('./platforms');
   const copiedTo = [];
   const resolved = targets.includes('all')
     ? resolveTargets('all')
     : targets.filter((t) => TARGETS[t]);
 
-  for (const targetId of resolved) {
-    const t = TARGETS[targetId];
-    const destinations = [{ root: t.root, layout: t.layout }];
-    if (t.also) destinations.push({ root: t.also.root, layout: t.also.layout });
-
-    for (const dest of destinations) {
-      fs.mkdirSync(dest.root, { recursive: true });
-      if (dest.layout === 'dir') {
-        const skillDir = path.join(dest.root, 'knowledge-bank');
-        fs.mkdirSync(skillDir, { recursive: true });
-        fs.copyFileSync(KNOWLEDGE_SKILL, path.join(skillDir, 'SKILL.md'));
-      } else {
-        fs.copyFileSync(KNOWLEDGE_SKILL, path.join(dest.root, 'knowledge-bank.md'));
-      }
-      copiedTo.push(`${targetId} → ${dest.root}`);
+  const destinations = scopeInfo.scope === 'project'
+    ? projectTargets(scopeInfo.projectRoot, resolved)
+    : resolved.map((id) => {
+        const t = TARGETS[id];
+        const list = [{ root: t.root, layout: t.layout, id }];
+        if (t.also) list.push({ root: t.also.root, layout: t.also.layout, id: `${id}-cmds` });
+        return list;
+      }).flat();
+
+  for (const dest of destinations) {
+    fs.mkdirSync(dest.root, { recursive: true });
+    if (dest.layout === 'dir') {
+      const skillDir = path.join(dest.root, 'knowledge-bank');
+      fs.mkdirSync(skillDir, { recursive: true });
+      fs.copyFileSync(KNOWLEDGE_SKILL, path.join(skillDir, 'SKILL.md'));
+    } else {
+      fs.copyFileSync(KNOWLEDGE_SKILL, path.join(dest.root, 'knowledge-bank.md'));
     }
+    copiedTo.push(`${dest.id} → ${dest.root}`);
   }
 
-  // Persist lastSync timestamp
-  config.lastSync = new Date().toISOString();
+  // Persist lastSync timestamp on the scoped config entry
+  if (scopeInfo.scope === 'global') {
+    config.lastSync = new Date().toISOString();
+  } else if (config.projects[scopeInfo.projectId]) {
+    config.projects[scopeInfo.projectId].lastSync = new Date().toISOString();
+  }
   saveConfig(config);
 
   // Knowledge bank content just changed for every project — drop any cached
   // knowledge-bank slices so the next run re-reads the fresh sync.
   try { require('./cache').invalidatePrefix('kb:'); } catch { /* cache module unavailable — fine */ }
 
-  return { synced: totalFiles, copiedTo };
+  return { synced: totalFiles, copiedTo, scope: scopeLabel };
 }
 
 function loadManifest(id) {
@@ -376,10 +514,24 @@ function getPersonaSliceForPrompt(state, personaId) {
 }
 
 /**
- * Return current config (sources list, lastSync).
+ * Return the config view for the resolved scope.
+ * Accepts the same { project, global, cwd } options as connect/sync.
+ * Returns { scope, projectId, sources, lastSync } so the CLI can print
+ * a scope-aware status without leaking other projects' sources.
  */
-function status() {
-  return loadConfig();
+function status(opts = {}) {
+  const config = loadConfig();
+  const scopeInfo = resolveProjectScope(opts);
+  const sources = scopedSources(config, scopeInfo) || [];
+  const lastSync = scopeInfo.scope === 'global'
+    ? config.lastSync
+    : (config.projects[scopeInfo.projectId] && config.projects[scopeInfo.projectId].lastSync);
+  return {
+    scope: scopeInfo.scope,
+    projectId: scopeInfo.projectId,
+    sources,
+    lastSync,
+  };
 }
 
-module.exports = { connect, disconnect, sync, status, buildPersonaSlice, writePersonaSlices, readPersonaSlice, getPersonaSliceForPrompt, KNOWLEDGE_SLICE_ROOT };
+module.exports = { connect, disconnect, sync, status, buildPersonaSlice, writePersonaSlices, readPersonaSlice, getPersonaSliceForPrompt, KNOWLEDGE_SLICE_ROOT, resolveProjectScope };