@soleri/core 9.2.0 → 9.3.1

package/src/planning/impact-analyzer.ts

@@ -31,21 +31,20 @@ export interface ImpactReport {
 // Constants
 // ---------------------------------------------------------------------------
 
-const CODE_EXTENSIONS = new Set([
-  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
-  '.vue', '.svelte',
-]);
+const CODE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.vue', '.svelte']);
 
-const TEST_PATTERNS = [
-  /\.test\./,
-  /\.spec\./,
-  /__tests__/,
-  /\.stories\./,
-];
+const TEST_PATTERNS = [/\.test\./, /\.spec\./, /__tests__/, /\.stories\./];
 
 const SKIP_DIRS = new Set([
-  'node_modules', '.git', 'dist', 'build', 'coverage',
-  '.next', '.nuxt', '.svelte-kit', '.turbo',
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  'coverage',
+  '.next',
+  '.nuxt',
+  '.svelte-kit',
+  '.turbo',
 ]);
 
 const MAX_FILES = 5000;
@@ -58,11 +57,7 @@ export class ImpactAnalyzer {
   /**
    * Analyze the downstream impact of modified files.
    */
-  analyzeImpact(
-    modifiedFiles: string[],
-    projectPath: string,
-    planScope?: string[],
-  ): ImpactReport {
+  analyzeImpact(modifiedFiles: string[], projectPath: string, planScope?: string[]): ImpactReport {
     if (modifiedFiles.length === 0 || !existsSync(projectPath)) {
       return emptyReport(modifiedFiles);
     }
@@ -72,11 +67,7 @@ export class ImpactAnalyzer {
     const untestedConsumers = filterUntested(consumers);
     const scopeViolations = detectScopeViolations(modifiedFiles, planScope);
     const riskLevel = assessRisk(consumers.length);
-    const recommendations = buildRecommendations(
-      consumers,
-      untestedConsumers,
-      scopeViolations,
-    );
+    const recommendations = buildRecommendations(consumers, untestedConsumers, scopeViolations);
 
     return {
       modifiedFiles,
@@ -166,18 +157,17 @@ function findConsumers(
 /**
  * Build regex-friendly stems from modified file paths.
  */
-function buildImportPatterns(
-  modifiedFiles: string[],
-  projectPath: string,
-): string[] {
-  return modifiedFiles.map((f) => {
-    const rel = f.startsWith('/') ? relative(projectPath, f) : f;
-    // Strip extension for import matching
-    const stem = rel.replace(/\.[^.]+$/, '');
-    // Also match the bare filename without extension
-    const bare = basename(rel).replace(/\.[^.]+$/, '');
-    return bare.length >= 3 ? bare : stem;
-  }).filter((p) => p.length >= 3);
+function buildImportPatterns(modifiedFiles: string[], projectPath: string): string[] {
+  return modifiedFiles
+    .map((f) => {
+      const rel = f.startsWith('/') ? relative(projectPath, f) : f;
+      // Strip extension for import matching
+      const stem = rel.replace(/\.[^.]+$/, '');
+      // Also match the bare filename without extension
+      const bare = basename(rel).replace(/\.[^.]+$/, '');
+      return bare.length >= 3 ? bare : stem;
+    })
+    .filter((p) => p.length >= 3);
 }
 
 /**
@@ -191,34 +181,28 @@ function matchImports(filePath: string, patterns: string[]): string[] {
     return [];
   }
 
-  const importRegex = /(?:import\s+.*?from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
+  const importRegex =
+    /(?:import\s+.*?from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
   const importPaths: string[] = [];
   let match: RegExpExecArray | null;
   while ((match = importRegex.exec(content)) !== null) {
     importPaths.push(match[1] ?? match[2]);
   }
 
-  return patterns.filter((p) =>
-    importPaths.some((imp) => imp.includes(p)),
-  );
+  return patterns.filter((p) => importPaths.some((imp) => imp.includes(p)));
 }
 
 /**
  * Filter consumers that are NOT test files.
  */
 function filterUntested(consumers: AffectedConsumer[]): string[] {
-  return consumers
-    .map((c) => c.file)
-    .filter((f) => !TEST_PATTERNS.some((p) => p.test(f)));
+  return consumers.map((c) => c.file).filter((f) => !TEST_PATTERNS.some((p) => p.test(f)));
 }
 
 /**
  * Flag modified files not in the declared plan scope.
  */
-function detectScopeViolations(
-  modifiedFiles: string[],
-  planScope?: string[],
-): string[] {
+function detectScopeViolations(modifiedFiles: string[], planScope?: string[]): string[] {
   if (!planScope || planScope.length === 0) return [];
 
   return modifiedFiles.filter((f) => {
@@ -248,7 +232,10 @@ function buildRecommendations(
 
   if (consumers.length > 0) {
     recs.push(
-      `Run tests for ${consumers.length} affected consumer(s): ${consumers.map((c) => c.file).slice(0, 5).join(', ')}`,
+      `Run tests for ${consumers.length} affected consumer(s): ${consumers
+        .map((c) => c.file)
+        .slice(0, 5)
+        .join(', ')}`,
     );
   }
 

package/src/planning/plan-lifecycle.test.ts

@@ -110,8 +110,15 @@ describe('plan-lifecycle', () => {
 
   describe('PlanGradeRejectionError', () => {
     it('contains grade, score, minGrade and gaps', () => {
-      const gaps = [{ id: 'g1', severity: 'critical' as const, category: 'structure',
-        description: 'Missing structure', recommendation: 'Fix it' }];
+      const gaps = [
+        {
+          id: 'g1',
+          severity: 'critical' as const,
+          category: 'structure',
+          description: 'Missing structure',
+          recommendation: 'Fix it',
+        },
+      ];
       const err = new PlanGradeRejectionError('C', 65, 'A', gaps);
       expect(err.grade).toBe('C');
       expect(err.score).toBe(65);
@@ -122,8 +129,20 @@ describe('plan-lifecycle', () => {
     });
     it('includes critical and major gaps in message', () => {
       const gaps = [
-        { id: 'g1', severity: 'critical' as const, category: 'x', description: 'Crit gap', recommendation: '' },
-        { id: 'g2', severity: 'minor' as const, category: 'x', description: 'Minor gap', recommendation: '' },
+        {
+          id: 'g1',
+          severity: 'critical' as const,
+          category: 'x',
+          description: 'Crit gap',
+          recommendation: '',
+        },
+        {
+          id: 'g2',
+          severity: 'minor' as const,
+          category: 'x',
+          description: 'Minor gap',
+          recommendation: '',
+        },
       ];
       const err = new PlanGradeRejectionError('D', 55, 'A', gaps);
       expect(err.message).toContain('Crit gap');
@@ -133,24 +152,33 @@ describe('plan-lifecycle', () => {
 
   describe('hasCircularDependencies', () => {
     it('returns false for no dependencies', () => {
-      expect(hasCircularDependencies([
-        { id: 'a' }, { id: 'b' },
-      ])).toBe(false);
+      expect(hasCircularDependencies([{ id: 'a' }, { id: 'b' }])).toBe(false);
     });
     it('returns false for linear dependencies', () => {
-      expect(hasCircularDependencies([
-        { id: 'a' }, { id: 'b', dependsOn: ['a'] }, { id: 'c', dependsOn: ['b'] },
-      ])).toBe(false);
+      expect(
+        hasCircularDependencies([
+          { id: 'a' },
+          { id: 'b', dependsOn: ['a'] },
+          { id: 'c', dependsOn: ['b'] },
+        ]),
+      ).toBe(false);
     });
     it('returns true for direct cycle', () => {
-      expect(hasCircularDependencies([
-        { id: 'a', dependsOn: ['b'] }, { id: 'b', dependsOn: ['a'] },
-      ])).toBe(true);
+      expect(
+        hasCircularDependencies([
+          { id: 'a', dependsOn: ['b'] },
+          { id: 'b', dependsOn: ['a'] },
+        ]),
+      ).toBe(true);
     });
     it('returns true for indirect cycle', () => {
-      expect(hasCircularDependencies([
-        { id: 'a', dependsOn: ['c'] }, { id: 'b', dependsOn: ['a'] }, { id: 'c', dependsOn: ['b'] },
-      ])).toBe(true);
+      expect(
+        hasCircularDependencies([
+          { id: 'a', dependsOn: ['c'] },
+          { id: 'b', dependsOn: ['a'] },
+          { id: 'c', dependsOn: ['b'] },
+        ]),
+      ).toBe(true);
     });
     it('returns true for self-dependency', () => {
       expect(hasCircularDependencies([{ id: 'a', dependsOn: ['a'] }])).toBe(true);
@@ -162,29 +190,60 @@ describe('plan-lifecycle', () => {
       expect(calculateScore([])).toBe(100);
     });
     it('deducts critical gaps at weight 30', () => {
-      const gaps = [{ id: 'g', severity: 'critical' as const, category: 'structure',
-        description: 'x', recommendation: 'y' }];
+      const gaps = [
+        {
+          id: 'g',
+          severity: 'critical' as const,
+          category: 'structure',
+          description: 'x',
+          recommendation: 'y',
+        },
+      ];
       expect(calculateScore(gaps)).toBe(70);
     });
     it('treats minor gaps as free on iteration 1', () => {
-      const gaps = [{ id: 'g', severity: 'minor' as const, category: 'clarity',
-        description: 'x', recommendation: 'y' }];
+      const gaps = [
+        {
+          id: 'g',
+          severity: 'minor' as const,
+          category: 'clarity',
+          description: 'x',
+          recommendation: 'y',
+        },
+      ];
       expect(calculateScore(gaps, 1)).toBe(100);
     });
     it('treats minor gaps at half weight on iteration 2', () => {
-      const gaps = [{ id: 'g', severity: 'minor' as const, category: 'clarity',
-        description: 'x', recommendation: 'y' }];
+      const gaps = [
+        {
+          id: 'g',
+          severity: 'minor' as const,
+          category: 'clarity',
+          description: 'x',
+          recommendation: 'y',
+        },
+      ];
       expect(calculateScore(gaps, 2)).toBe(99);
     });
     it('treats minor gaps at full weight on iteration 3', () => {
-      const gaps = [{ id: 'g', severity: 'minor' as const, category: 'clarity',
-        description: 'x', recommendation: 'y' }];
+      const gaps = [
+        {
+          id: 'g',
+          severity: 'minor' as const,
+          category: 'clarity',
+          description: 'x',
+          recommendation: 'y',
+        },
+      ];
       expect(calculateScore(gaps, 3)).toBe(98);
     });
     it('floors at 0', () => {
       const gaps = Array.from({ length: 5 }, (_, i) => ({
-        id: `g${i}`, severity: 'critical' as const, category: `cat${i}`,
-        description: 'x', recommendation: 'y',
+        id: `g${i}`,
+        severity: 'critical' as const,
+        category: `cat${i}`,
+        description: 'x',
+        recommendation: 'y',
       }));
       expect(calculateScore(gaps)).toBe(0);
     });
@@ -201,7 +260,9 @@ describe('plan-lifecycle', () => {
     });
     it('adds tasks with correct IDs', () => {
       const plan = makePlan();
-      plan.tasks = [{ id: 'task-1', title: 'T1', description: 'd', status: 'pending', updatedAt: 0 }];
+      plan.tasks = [
+        { id: 'task-1', title: 'T1', description: 'd', status: 'pending', updatedAt: 0 },
+      ];
       applyIteration(plan, { addTasks: [{ title: 'T2', description: 'd2' }] });
       expect(plan.tasks).toHaveLength(2);
       expect(plan.tasks[1].id).toBe('task-2');
@@ -230,22 +291,24 @@ describe('plan-lifecycle', () => {
     });
     it('throws on unknown dependency', () => {
       const plan = createPlanObject({ objective: 'test', scope: 'test' });
-      expect(() => applySplitTasks(plan, [
-        { title: 'A', description: 'a', dependsOn: ['task-99'] },
-      ])).toThrow('depends on unknown task');
+      expect(() =>
+        applySplitTasks(plan, [{ title: 'A', description: 'a', dependsOn: ['task-99'] }]),
+      ).toThrow('depends on unknown task');
     });
     it('preserves acceptance criteria', () => {
       const plan = createPlanObject({ objective: 'test', scope: 'test' });
-      applySplitTasks(plan, [
-        { title: 'A', description: 'a', acceptanceCriteria: ['cr1', 'cr2'] },
-      ]);
+      applySplitTasks(plan, [{ title: 'A', description: 'a', acceptanceCriteria: ['cr1', 'cr2'] }]);
       expect(plan.tasks[0].acceptanceCriteria).toEqual(['cr1', 'cr2']);
     });
   });
 
   describe('applyTaskStatusUpdate', () => {
     const makeTask = (): PlanTask => ({
-      id: 'task-1', title: 'T', description: 'd', status: 'pending', updatedAt: 0,
+      id: 'task-1',
+      title: 'T',
+      description: 'd',
+      status: 'pending',
+      updatedAt: 0,
     });
 
     it('sets startedAt on first in_progress', () => {
@@ -295,8 +358,12 @@ describe('plan-lifecycle', () => {
     });
     it('creates numbered tasks', () => {
       const plan = createPlanObject({
-        objective: 'x', scope: 'y',
-        tasks: [{ title: 'A', description: 'a' }, { title: 'B', description: 'b' }],
+        objective: 'x',
+        scope: 'y',
+        tasks: [
+          { title: 'A', description: 'a' },
+          { title: 'B', description: 'b' },
+        ],
       });
       expect(plan.tasks[0].id).toBe('task-1');
       expect(plan.tasks[1].id).toBe('task-2');

package/src/planning/plan-lifecycle.ts

@@ -229,10 +229,17 @@ export function hasCircularDependencies(
 import type { PlanTask, TaskStatus, Plan, PlanDecision } from './planner-types.js';
 
 export interface IterateChanges {
-  objective?: string; scope?: string; decisions?: (string | PlanDecision)[];
-  addTasks?: Array<{ title: string; description: string }>; removeTasks?: string[];
-  approach?: string; context?: string; success_criteria?: string[];
-  tool_chain?: string[]; flow?: string; target_mode?: string;
+  objective?: string;
+  scope?: string;
+  decisions?: (string | PlanDecision)[];
+  addTasks?: Array<{ title: string; description: string }>;
+  removeTasks?: string[];
+  approach?: string;
+  context?: string;
+  success_criteria?: string[];
+  tool_chain?: string[];
+  flow?: string;
+  target_mode?: string;
 }
 
 /**
@@ -261,8 +268,11 @@ export function applyIteration(plan: Plan, changes: IterateChanges): void {
     }, 0);
     for (let i = 0; i < changes.addTasks.length; i++) {
       plan.tasks.push({
-        id: `task-${maxIndex + i + 1}`, title: changes.addTasks[i].title,
-        description: changes.addTasks[i].description, status: 'pending' as TaskStatus, updatedAt: now,
+        id: `task-${maxIndex + i + 1}`,
+        title: changes.addTasks[i].title,
+        description: changes.addTasks[i].description,
+        status: 'pending' as TaskStatus,
+        updatedAt: now,
       });
     }
   }
@@ -295,23 +305,32 @@ export function applyTaskStatusUpdate(task: PlanTask, status: TaskStatus): void
  * Create a new Plan object (factory). Does not persist.
  */
 export function createPlanObject(params: {
-  objective: string; scope: string;
+  objective: string;
+  scope: string;
   decisions?: (string | PlanDecision)[];
   tasks?: Array<{ title: string; description: string }>;
-  approach?: string; context?: string; success_criteria?: string[];
-  tool_chain?: string[]; flow?: string; target_mode?: string;
+  approach?: string;
+  context?: string;
+  success_criteria?: string[];
+  tool_chain?: string[];
+  flow?: string;
+  target_mode?: string;
   alternatives?: import('./planner-types.js').PlanAlternative[];
   initialStatus?: 'brainstorming' | 'draft';
 }): Plan {
   const now = Date.now();
   return {
     id: `plan-${now}-${Math.random().toString(36).slice(2, 8)}`,
-    objective: params.objective, scope: params.scope,
+    objective: params.objective,
+    scope: params.scope,
     status: params.initialStatus ?? 'draft',
     decisions: params.decisions ?? [],
     tasks: (params.tasks ?? []).map((t, i) => ({
-      id: `task-${i + 1}`, title: t.title, description: t.description,
-      status: 'pending' as TaskStatus, updatedAt: now,
+      id: `task-${i + 1}`,
+      title: t.title,
+      description: t.description,
+      status: 'pending' as TaskStatus,
+      updatedAt: now,
     })),
     ...(params.approach !== undefined && { approach: params.approach }),
     ...(params.context !== undefined && { context: params.context }),
@@ -320,25 +339,37 @@ export function createPlanObject(params: {
     ...(params.flow !== undefined && { flow: params.flow }),
     ...(params.target_mode !== undefined && { target_mode: params.target_mode }),
     ...(params.alternatives !== undefined && { alternatives: params.alternatives }),
-    checks: [], createdAt: now, updatedAt: now,
+    checks: [],
+    createdAt: now,
+    updatedAt: now,
   };
 }
 
 export function applySplitTasks(
   plan: Plan,
-  tasks: Array<{ title: string; description: string; dependsOn?: string[]; acceptanceCriteria?: string[] }>,
+  tasks: Array<{
+    title: string;
+    description: string;
+    dependsOn?: string[];
+    acceptanceCriteria?: string[];
+  }>,
 ): void {
   const now = Date.now();
   plan.tasks = tasks.map((t, i) => ({
-    id: `task-${i + 1}`, title: t.title, description: t.description,
-    status: 'pending' as TaskStatus, dependsOn: t.dependsOn,
-    ...(t.acceptanceCriteria && { acceptanceCriteria: t.acceptanceCriteria }), updatedAt: now,
+    id: `task-${i + 1}`,
+    title: t.title,
+    description: t.description,
+    status: 'pending' as TaskStatus,
+    dependsOn: t.dependsOn,
+    ...(t.acceptanceCriteria && { acceptanceCriteria: t.acceptanceCriteria }),
+    updatedAt: now,
   }));
   const taskIds = new Set(plan.tasks.map((t) => t.id));
   for (const task of plan.tasks) {
     if (task.dependsOn) {
       for (const dep of task.dependsOn) {
-        if (!taskIds.has(dep)) throw new Error(`Task '${task.id}' depends on unknown task '${dep}'`);
+        if (!taskIds.has(dep))
+          throw new Error(`Task '${task.id}' depends on unknown task '${dep}'`);
       }
     }
   }

package/src/planning/planner.test.ts

@@ -9,8 +9,18 @@ import { tmpdir } from 'node:os';
 
 /** Two well-structured alternatives to satisfy pass 8. */
 const TWO_ALTERNATIVES: PlanAlternative[] = [
-  { approach: 'Use alternative A', pros: ['Pro A'], cons: ['Con A'], rejected_reason: 'Not suitable for our use case' },
-  { approach: 'Use alternative B', pros: ['Pro B'], cons: ['Con B'], rejected_reason: 'Too complex for the scope' },
+  {
+    approach: 'Use alternative A',
+    pros: ['Pro A'],
+    cons: ['Con A'],
+    rejected_reason: 'Not suitable for our use case',
+  },
+  {
+    approach: 'Use alternative B',
+    pros: ['Pro B'],
+    cons: ['Con B'],
+    rejected_reason: 'Too complex for the scope',
+  },
 ];
 
 describe('Planner', () => {