@soleri/core 9.2.0 → 9.3.0

package/src/planning/gap-patterns.test.ts

@@ -30,13 +30,40 @@ function makePlan(overrides: Partial<Plan> = {}): Plan {
     scope: 'Auth module, middleware, and user service. Does not include OAuth providers.',
     status: 'draft',
     decisions: [
-      { decision: 'Use JWT for stateless auth', rationale: 'Because it scales horizontally without shared session store' },
+      {
+        decision: 'Use JWT for stateless auth',
+        rationale: 'Because it scales horizontally without shared session store',
+      },
     ],
     tasks: [
-      { id: 'task-1', title: 'Add JWT signing', description: 'Implement JWT sign/verify using built-in crypto module', status: 'pending', updatedAt: Date.now() },
-      { id: 'task-2', title: 'Add auth middleware', description: 'Create Express middleware that validates JWT from Authorization header', status: 'pending', updatedAt: Date.now() },
-      { id: 'task-3', title: 'Add login endpoint', description: 'POST /auth/login returns JWT after verifying credentials', status: 'pending', updatedAt: Date.now() },
-      { id: 'task-4', title: 'Add test coverage', description: 'Test JWT signing, middleware rejection, and login flow end-to-end', status: 'pending', updatedAt: Date.now() },
+      {
+        id: 'task-1',
+        title: 'Add JWT signing',
+        description: 'Implement JWT sign/verify using built-in crypto module',
+        status: 'pending',
+        updatedAt: Date.now(),
+      },
+      {
+        id: 'task-2',
+        title: 'Add auth middleware',
+        description: 'Create Express middleware that validates JWT from Authorization header',
+        status: 'pending',
+        updatedAt: Date.now(),
+      },
+      {
+        id: 'task-3',
+        title: 'Add login endpoint',
+        description: 'POST /auth/login returns JWT after verifying credentials',
+        status: 'pending',
+        updatedAt: Date.now(),
+      },
+      {
+        id: 'task-4',
+        title: 'Add test coverage',
+        description: 'Test JWT signing, middleware rejection, and login flow end-to-end',
+        status: 'pending',
+        updatedAt: Date.now(),
+      },
     ],
     checks: [],
     createdAt: Date.now(),
@@ -178,7 +205,9 @@ describe('Pass 1: Structure', () => {
   it('returns critical gap for missing objective', () => {
     const gaps = analyzeStructure(makePlan({ objective: '' }));
     expect(gaps.some((g) => g._trigger === 'missing_or_short_objective')).toBe(true);
-    expect(gaps.find((g) => g._trigger === 'missing_or_short_objective')?.severity).toBe('critical');
+    expect(gaps.find((g) => g._trigger === 'missing_or_short_objective')?.severity).toBe(
+      'critical',
+    );
   });
 
   it('returns critical gap for short objective', () => {
@@ -258,10 +287,37 @@ describe('Pass 3: Feasibility', () => {
   it('does not flag when tasks have dependsOn', () => {
     const plan = makePlan({
       tasks: [
-        { id: 't1', title: 'Setup', description: 'Setup project', status: 'pending', updatedAt: Date.now() },
-        { id: 't2', title: 'Build', description: 'Build feature', status: 'pending', dependsOn: ['t1'], updatedAt: Date.now() },
-        { id: 't3', title: 'Test', description: 'Test feature', status: 'pending', dependsOn: ['t2'], updatedAt: Date.now() },
-        { id: 't4', title: 'Deploy', description: 'Deploy to prod', status: 'pending', dependsOn: ['t3'], updatedAt: Date.now() },
+        {
+          id: 't1',
+          title: 'Setup',
+          description: 'Setup project',
+          status: 'pending',
+          updatedAt: Date.now(),
+        },
+        {
+          id: 't2',
+          title: 'Build',
+          description: 'Build feature',
+          status: 'pending',
+          dependsOn: ['t1'],
+          updatedAt: Date.now(),
+        },
+        {
+          id: 't3',
+          title: 'Test',
+          description: 'Test feature',
+          status: 'pending',
+          dependsOn: ['t2'],
+          updatedAt: Date.now(),
+        },
+        {
+          id: 't4',
+          title: 'Deploy',
+          description: 'Deploy to prod',
+          status: 'pending',
+          dependsOn: ['t3'],
+          updatedAt: Date.now(),
+        },
       ],
     });
     const gaps = analyzeFeasibility(plan);
@@ -271,8 +327,20 @@ describe('Pass 3: Feasibility', () => {
   it('does not flag when 3 or fewer tasks', () => {
     const plan = makePlan({
       tasks: [
-        { id: 't1', title: 'Task 1', description: 'Do something', status: 'pending', updatedAt: Date.now() },
-        { id: 't2', title: 'Task 2', description: 'Do another thing', status: 'pending', updatedAt: Date.now() },
+        {
+          id: 't1',
+          title: 'Task 1',
+          description: 'Do something',
+          status: 'pending',
+          updatedAt: Date.now(),
+        },
+        {
+          id: 't2',
+          title: 'Task 2',
+          description: 'Do another thing',
+          status: 'pending',
+          updatedAt: Date.now(),
+        },
       ],
     });
     const gaps = analyzeFeasibility(plan);
@@ -305,7 +373,13 @@ describe('Pass 4: Risk', () => {
       scope: 'Auth module only. Not including user service.',
       decisions: [{ decision: 'Use new pattern', rationale: 'Because it is cleaner code' }],
       tasks: [
-        { id: 't1', title: 'Refactor auth', description: 'Change the auth flow implementation', status: 'pending', updatedAt: Date.now() },
+        {
+          id: 't1',
+          title: 'Refactor auth',
+          description: 'Change the auth flow implementation',
+          status: 'pending',
+          updatedAt: Date.now(),
+        },
       ],
     });
     const gaps = analyzeRisk(plan);

package/src/planning/gap-patterns.ts

@@ -59,35 +59,81 @@ export function containsAny(text: string, patterns: string[]): boolean {
 // ─── Pattern Constants (Passes 1-4) ─────────────────────────────
 
 export const METRIC_PATTERNS = [
-  /\d+/, /percent/i, /reduce/i, /increase/i, /measure/i,
-  /target/i, /goal/i, /kpi/i, /metric/i, /benchmark/i,
+  /\d+/,
+  /percent/i,
+  /reduce/i,
+  /increase/i,
+  /measure/i,
+  /target/i,
+  /goal/i,
+  /kpi/i,
+  /metric/i,
+  /benchmark/i,
 ];
 
 export const EXCLUSION_KEYWORDS = [
-  'not', 'exclude', 'outside', 'beyond', 'limit', 'except', "won't", 'will not',
+  'not',
+  'exclude',
+  'outside',
+  'beyond',
+  'limit',
+  'except',
+  "won't",
+  'will not',
 ];
 
 export const OVERLY_BROAD_PATTERNS = [
-  'everything', 'all systems', 'entire codebase', 'complete rewrite',
-  'from scratch', 'total overhaul', 'rewrite everything',
+  'everything',
+  'all systems',
+  'entire codebase',
+  'complete rewrite',
+  'from scratch',
+  'total overhaul',
+  'rewrite everything',
 ];
 
 export const DEPENDENCY_KEYWORDS = [
-  'depends', 'dependency', 'prerequisite', 'requires', 'blocked', 'before',
+  'depends',
+  'dependency',
+  'prerequisite',
+  'requires',
+  'blocked',
+  'before',
 ];
 
 export const BREAKING_CHANGE_KEYWORDS = [
-  'breaking change', 'breaking', 'migration', 'deprecate',
-  'remove api', 'remove endpoint', 'schema change', 'database migration',
+  'breaking change',
+  'breaking',
+  'migration',
+  'deprecate',
+  'remove api',
+  'remove endpoint',
+  'schema change',
+  'database migration',
 ];
 
 export const MITIGATION_KEYWORDS = [
-  'rollback', 'backward compatible', 'backwards compatible', 'feature flag',
-  'gradual', 'phased', 'fallback', 'backup', 'canary', 'blue-green',
+  'rollback',
+  'backward compatible',
+  'backwards compatible',
+  'feature flag',
+  'gradual',
+  'phased',
+  'fallback',
+  'backup',
+  'canary',
+  'blue-green',
 ];
 
 export const VERIFICATION_KEYWORDS = [
-  'test', 'verify', 'validate', 'check', 'assert', 'confirm', 'spec', 'coverage',
+  'test',
+  'verify',
+  'validate',
+  'check',
+  'assert',
+  'confirm',
+  'spec',
+  'coverage',
 ];
 
 // ─── Pass 1: Structure ───────────────────────────────────────────
@@ -98,12 +144,14 @@ export function analyzeStructure(plan: Plan): PlanGap[] {
   if (!plan.objective || plan.objective.trim().length < MIN_OBJECTIVE_LENGTH) {
     gaps.push(
       gap(
-        'critical', 'structure',
+        'critical',
+        'structure',
         plan.objective
           ? `Objective too short (${plan.objective.trim().length} chars, need ${MIN_OBJECTIVE_LENGTH}+).`
           : 'Plan has no objective.',
         'Add a clear objective describing what this plan achieves.',
-        'objective', 'missing_or_short_objective',
+        'objective',
+        'missing_or_short_objective',
       ),
     );
   }
@@ -111,21 +159,28 @@ export function analyzeStructure(plan: Plan): PlanGap[] {
   if (!plan.scope || plan.scope.trim().length < MIN_SCOPE_LENGTH) {
     gaps.push(
       gap(
-        'critical', 'structure',
+        'critical',
+        'structure',
         plan.scope
           ? `Scope too short (${plan.scope.trim().length} chars, need ${MIN_SCOPE_LENGTH}+).`
           : 'Plan has no scope defined.',
         'Define the scope — what is included and excluded.',
-        'scope', 'missing_or_short_scope',
+        'scope',
+        'missing_or_short_scope',
       ),
     );
   }
 
   if (plan.tasks.length === 0) {
     gaps.push(
-      gap('critical', 'structure', 'Plan has no tasks.',
+      gap(
+        'critical',
+        'structure',
+        'Plan has no tasks.',
         'Add at least one task to make the plan actionable.',
-        'tasks', 'no_tasks'),
+        'tasks',
+        'no_tasks',
+      ),
     );
   }
 
@@ -139,10 +194,14 @@ export function analyzeCompleteness(plan: Plan): PlanGap[] {
 
   if (plan.objective && !METRIC_PATTERNS.some((p) => p.test(plan.objective))) {
     gaps.push(
-      gap('minor', 'completeness',
+      gap(
+        'minor',
+        'completeness',
         'Objective has no measurable targets or metrics.',
         'Include quantifiable success criteria (numbers, percentages, concrete outcomes).',
-        'objective', 'no_metrics_in_objective'),
+        'objective',
+        'no_metrics_in_objective',
+      ),
     );
   }
 
@@ -152,10 +211,14 @@ export function analyzeCompleteness(plan: Plan): PlanGap[] {
       const text = decisionText(d);
       if (text.trim().length < MIN_DECISION_LENGTH) {
         gaps.push(
-          gap('major', 'completeness',
+          gap(
+            'major',
+            'completeness',
             `Decision ${i + 1} is too short (${text.trim().length} chars) — lacks rationale.`,
             'Expand each decision to include the reasoning (why this choice over alternatives).',
-            `decisions[${i}]`, 'short_decision'),
+            `decisions[${i}]`,
+            'short_decision',
+          ),
         );
       }
     }
@@ -163,10 +226,14 @@ export function analyzeCompleteness(plan: Plan): PlanGap[] {
 
   if (plan.scope && !containsAny(plan.scope, EXCLUSION_KEYWORDS)) {
     gaps.push(
-      gap('minor', 'completeness',
+      gap(
+        'minor',
+        'completeness',
         'Scope does not mention what is excluded.',
         'Add explicit exclusions to prevent scope creep (e.g., "does NOT include…").',
-        'scope', 'no_exclusions_in_scope'),
+        'scope',
+        'no_exclusions_in_scope',
+      ),
     );
   }
 
@@ -181,10 +248,14 @@ export function analyzeFeasibility(plan: Plan): PlanGap[] {
 
   if (containsAny(scopeAndTasks, OVERLY_BROAD_PATTERNS)) {
     gaps.push(
-      gap('major', 'feasibility',
+      gap(
+        'major',
+        'feasibility',
         'Scope contains overly broad indicators — risk of unrealistic delivery.',
         'Narrow the scope to a well-defined subset. Prefer incremental delivery over big-bang rewrites.',
-        'scope', 'overly_broad_scope'),
+        'scope',
+        'overly_broad_scope',
+      ),
     );
   }
 
@@ -192,10 +263,14 @@ export function analyzeFeasibility(plan: Plan): PlanGap[] {
     const hasDeps = plan.tasks.some((t) => t.dependsOn && t.dependsOn.length > 0);
     if (!hasDeps) {
       gaps.push(
-        gap('minor', 'feasibility',
+        gap(
+          'minor',
+          'feasibility',
           `${plan.tasks.length} tasks with no dependency mentions — execution order unclear.`,
           'Identify dependencies between tasks or add explicit ordering notes.',
-          'tasks', 'no_dependency_awareness'),
+          'tasks',
+          'no_dependency_awareness',
+        ),
       );
     }
   }
@@ -214,19 +289,27 @@ export function analyzeRisk(plan: Plan): PlanGap[] {
     !containsAny(allText, MITIGATION_KEYWORDS)
   ) {
     gaps.push(
-      gap('major', 'risk',
+      gap(
+        'major',
+        'risk',
         'Plan involves breaking changes but mentions no mitigation strategy.',
         'Add a rollback plan, feature flags, or phased migration approach.',
-        undefined, 'breaking_without_mitigation'),
+        undefined,
+        'breaking_without_mitigation',
+      ),
     );
   }
 
   if (plan.tasks.length > 0 && !containsAny(allText, VERIFICATION_KEYWORDS)) {
     gaps.push(
-      gap('minor', 'risk',
+      gap(
+        'minor',
+        'risk',
         'No verification or testing mentioned in the plan.',
         'Add at least one task or note about testing/validation.',
-        'tasks', 'no_verification_mentioned'),
+        'tasks',
+        'no_verification_mentioned',
+      ),
     );
   }
 

package/src/planning/github-projection.test.ts

@@ -129,7 +129,12 @@ describe('github-projection', () => {
       ],
       tasks: [
         { id: 'task-1', title: 'Design auth schema', description: 'Create DB tables' },
-        { id: 'task-2', title: 'Implement login', description: 'Login endpoint', dependsOn: ['task-1'] },
+        {
+          id: 'task-2',
+          title: 'Implement login',
+          description: 'Login endpoint',
+          dependsOn: ['task-1'],
+        },
       ],
     };
 

package/src/planning/github-projection.ts

@@ -129,7 +129,12 @@ export function listMilestones(repo: GitHubRepo): GitHubMilestone[] {
   try {
     const output = execFileSync(
       'gh',
-      ['api', `repos/${repo.owner}/${repo.repo}/milestones`, '--jq', '.[] | {number, title, state}'],
+      [
+        'api',
+        `repos/${repo.owner}/${repo.repo}/milestones`,
+        '--jq',
+        '.[] | {number, title, state}',
+      ],
       {
         encoding: 'utf-8',
         timeout: 10000,
@@ -157,11 +162,16 @@ export function listOpenIssues(repo: GitHubRepo, limit: number = 100): GitHubIss
     const output = execFileSync(
       'gh',
       [
-        'issue', 'list',
-        '--repo', `${repo.owner}/${repo.repo}`,
-        '--state', 'open',
-        '--limit', String(limit),
-        '--json', 'number,title,state,body',
+        'issue',
+        'list',
+        '--repo',
+        `${repo.owner}/${repo.repo}`,
+        '--state',
+        'open',
+        '--limit',
+        String(limit),
+        '--json',
+        'number,title,state,body',
       ],
       {
         encoding: 'utf-8',
@@ -184,11 +194,7 @@ export function listLabels(repo: GitHubRepo): GitHubLabel[] {
   try {
     const output = execFileSync(
       'gh',
-      [
-        'label', 'list',
-        '--repo', `${repo.owner}/${repo.repo}`,
-        '--json', 'name,color',
-      ],
+      ['label', 'list', '--repo', `${repo.owner}/${repo.repo}`, '--json', 'name,color'],
       {
         encoding: 'utf-8',
         timeout: 10000,
@@ -273,10 +279,18 @@ export function findDuplicateIssue(
   taskTitle: string,
   existingIssues: GitHubIssue[],
 ): GitHubIssue | null {
-  const taskWords = new Set(taskTitle.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  const taskWords = new Set(
+    taskTitle
+      .toLowerCase()
+      .split(/\s+/)
+      .filter((w) => w.length > 2),
+  );
 
   for (const issue of existingIssues) {
-    const issueWords = issue.title.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+    const issueWords = issue.title
+      .toLowerCase()
+      .split(/\s+/)
+      .filter((w) => w.length > 2);
     let overlap = 0;
     for (const w of issueWords) {
       if (taskWords.has(w)) overlap++;
@@ -367,10 +381,14 @@ export function createGitHubIssue(
 ): number | null {
   try {
     const args = [
-      'issue', 'create',
-      '--repo', `${repo.owner}/${repo.repo}`,
-      '--title', title,
-      '--body', body,
+      'issue',
+      'create',
+      '--repo',
+      `${repo.owner}/${repo.repo}`,
+      '--title',
+      title,
+      '--body',
+      body,
     ];
 
     if (options?.milestone) {
@@ -407,10 +425,13 @@ export function updateGitHubIssueBody(
     execFileSync(
       'gh',
       [
-        'issue', 'edit',
-        '--repo', `${repo.owner}/${repo.repo}`,
+        'issue',
+        'edit',
+        '--repo',
+        `${repo.owner}/${repo.repo}`,
         String(issueNumber),
-        '--body', body,
+        '--body',
+        body,
       ],
       {
         encoding: 'utf-8',

package/src/planning/impact-analyzer.test.ts

@@ -14,7 +14,9 @@ function setup() {
 function teardown() {
   try {
     rmSync(TMP, { recursive: true, force: true });
-  } catch { /* ignore */ }
+  } catch {
+    /* ignore */
+  }
 }
 
 describe('ImpactAnalyzer', () => {
@@ -65,10 +67,7 @@ describe('ImpactAnalyzer', () => {
       join(TMP, 'src', 'components', 'b.ts'),
       "import { format } from '../utils/format';",
     );
-    writeFileSync(
-      join(TMP, 'src', 'components', 'c.ts'),
-      "const f = require('../utils/format');",
-    );
+    writeFileSync(join(TMP, 'src', 'components', 'c.ts'), "const f = require('../utils/format');");
 
     const report = analyzer.analyzeImpact(['src/utils/format.ts'], TMP);
 
@@ -100,11 +99,9 @@ describe('ImpactAnalyzer', () => {
   it('detects scope violations when files are outside plan scope', () => {
     writeFileSync(join(TMP, 'src', 'utils', 'misc.ts'), 'export const x = 1;');
 
-    const report = analyzer.analyzeImpact(
-      ['src/utils/misc.ts', 'src/components/button.ts'],
-      TMP,
-      ['components'],
-    );
+    const report = analyzer.analyzeImpact(['src/utils/misc.ts', 'src/components/button.ts'], TMP, [
+      'components',
+    ]);
 
     expect(report.scopeViolations).toContain('src/utils/misc.ts');
     expect(report.scopeViolations).not.toContain('src/components/button.ts');
@@ -134,11 +131,7 @@ describe('ImpactAnalyzer', () => {
   it('includes scope violation in recommendations', () => {
     writeFileSync(join(TMP, 'src', 'utils', 'oops.ts'), 'export const x = 1;');
 
-    const report = analyzer.analyzeImpact(
-      ['src/utils/oops.ts'],
-      TMP,
-      ['components'],
-    );
+    const report = analyzer.analyzeImpact(['src/utils/oops.ts'], TMP, ['components']);
 
     const recText = report.recommendations.join(' ');
     expect(recText).toContain('Scope violation');
@@ -148,10 +141,7 @@ describe('ImpactAnalyzer', () => {
 
   it('separates test files from untested consumers', () => {
     writeFileSync(join(TMP, 'src', 'utils', 'api.ts'), 'export const api = 1;');
-    writeFileSync(
-      join(TMP, 'src', 'components', 'page.ts'),
-      "import { api } from '../utils/api';",
-    );
+    writeFileSync(join(TMP, 'src', 'components', 'page.ts'), "import { api } from '../utils/api';");
     writeFileSync(
       join(TMP, 'src', '__tests__', 'api.test.ts'),
       "import { api } from '../utils/api';",
@@ -168,10 +158,7 @@ describe('ImpactAnalyzer', () => {
   // ─── Graceful when project path doesn't exist ──────────────
 
   it('returns low risk when project path does not exist', () => {
-    const report = analyzer.analyzeImpact(
-      ['src/foo.ts'],
-      '/nonexistent/path/12345',
-    );
+    const report = analyzer.analyzeImpact(['src/foo.ts'], '/nonexistent/path/12345');
 
     expect(report.riskLevel).toBe('low');
     expect(report.affectedConsumers).toHaveLength(0);