@archora/core 1.1.0

package/src/codegen/configSnippets.ts

@@ -0,0 +1,172 @@
+import type { ArchoraConfig, GeneratedPolicy } from '../config/frontScopeConfig';
+import type { LayerViolation, ScanResult } from '../analyzer/types';
+
+export interface SnippetOptions {
+  indent?: number;
+}
+
+const DEFAULT_INDENT = 2;
+
+export type ProjectPolicyPreset = 'fsd' | 'package-workspace' | 'generated-openapi';
+
+export function buildProjectPolicyPresetSnippet(
+  preset: ProjectPolicyPreset,
+  options: SnippetOptions = {},
+): string {
+  return JSON.stringify(projectPolicyPreset(preset), null, options.indent ?? DEFAULT_INDENT);
+}
+
+export function buildGeneratedConfigSnippet(
+  policy: GeneratedPolicy,
+  options: SnippetOptions = {},
+): string {
+  const block: Record<string, unknown> = { mode: policy.mode };
+  if (policy.patterns && policy.patterns.length > 0) block['patterns'] = policy.patterns;
+  if (policy.presets && policy.presets.length > 0) block['presets'] = policy.presets;
+  return JSON.stringify({ analysis: { generated: block } }, null, options.indent ?? DEFAULT_INDENT);
+}
+
+export function buildIgnoreSnippet(
+  patterns: readonly string[],
+  options: SnippetOptions = {},
+): string {
+  return JSON.stringify(
+    { ignore: dedupeNonEmpty(patterns) },
+    null,
+    options.indent ?? DEFAULT_INDENT,
+  );
+}
+
+export function buildLayerOverrideSnippet(
+  violations: readonly LayerViolation[],
+  options: SnippetOptions = {},
+): string {
+  const counts = new Map<string, Map<string, number>>();
+  for (const v of violations) {
+    const byLayer = counts.get(v.to) ?? new Map<string, number>();
+    byLayer.set(v.fromLayer, (byLayer.get(v.fromLayer) ?? 0) + 1);
+    counts.set(v.to, byLayer);
+  }
+  const overrides: Record<string, string> = {};
+  for (const [moduleId, byLayer] of counts) {
+    const top = pickTop(byLayer);
+    if (top) overrides[moduleId] = top;
+  }
+  return JSON.stringify({ layerOverrides: overrides }, null, options.indent ?? DEFAULT_INDENT);
+}
+
+export function buildDynamicLoaderSnippet(scan: ScanResult, options: SnippetOptions = {}): string {
+  const seen = new Set<string>();
+  const samples: { specifier: string; resolveAs: string }[] = [];
+  for (const e of scan.edges) {
+    if (e.resolutionKind !== 'prefix' && e.resolutionKind !== 'glob') continue;
+    if (seen.has(e.specifier)) continue;
+    seen.add(e.specifier);
+    samples.push({ specifier: e.specifier, resolveAs: dynamicResolveTemplate(e.specifier) });
+    if (samples.length >= 5) break;
+  }
+  const block = samples.map((s, i) => ({
+    name: `dynamic-loader-${i + 1}`,
+    resolveAs: s.resolveAs,
+    description: `Observed pattern: ${s.specifier}`,
+  }));
+  return JSON.stringify({ dynamicLoaders: block }, null, options.indent ?? DEFAULT_INDENT);
+}
+
+function projectPolicyPreset(preset: ProjectPolicyPreset): ArchoraConfig {
+  switch (preset) {
+    case 'fsd':
+      return {
+        contracts: {
+          boundaries: [
+            {
+              name: 'features-isolation',
+              from: 'src/features/*/**',
+              to: 'src/features/*/**',
+              mode: 'must-not',
+              crossInstance: true,
+              severity: 'warning',
+              description: 'Feature slices should talk through shared APIs, not sibling internals.',
+            },
+            {
+              name: 'shared-not-ui-layers',
+              from: 'src/shared/**',
+              to: 'src/**',
+              mode: 'must-not',
+              except: ['src/shared/**'],
+              severity: 'error',
+              description: 'Shared code should stay independent from product layers.',
+            },
+          ],
+        },
+      };
+    case 'package-workspace':
+      return {
+        contracts: {
+          boundaries: [
+            {
+              name: 'packages-through-public-api',
+              from: 'packages/*/src/**',
+              to: 'packages/*/src/**',
+              mode: 'must-not',
+              crossInstance: true,
+              except: ['packages/*/src/index.*'],
+              severity: 'warning',
+              description:
+                'Workspace packages should consume sibling packages through public APIs.',
+            },
+          ],
+          budgets: [
+            {
+              name: 'package-entry-fanout',
+              module: 'packages/*/src/index.*',
+              maxFanOut: 12,
+              severity: 'warning',
+              description: 'Package entry points should stay narrow enough to review.',
+            },
+          ],
+        },
+      };
+    case 'generated-openapi':
+      return {
+        analysis: {
+          generated: {
+            mode: 'classify',
+            presets: ['openapi', 'generated-folder'],
+          },
+        },
+      };
+  }
+}
+
+function dedupeNonEmpty(input: readonly string[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const raw of input) {
+    if (typeof raw !== 'string') continue;
+    const trimmed = raw.trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    out.push(trimmed);
+  }
+  return out;
+}
+
+function pickTop(counts: Map<string, number>): string | null {
+  let best: string | null = null;
+  let bestCount = -1;
+  for (const [layer, c] of counts) {
+    if (c > bestCount || (c === bestCount && best !== null && layer.localeCompare(best) < 0)) {
+      best = layer;
+      bestCount = c;
+    }
+  }
+  return best;
+}
+
+function dynamicResolveTemplate(specifier: string): string {
+  const normalized = specifier.replace(/\\/g, '/');
+  if (normalized.endsWith('/')) return `${normalized}{0}/index`;
+  if (normalized.includes('*')) return normalized.replace(/\*+/g, '{0}');
+  return `${normalized}/{0}/index`;
+}

package/src/codegen/initConfig.ts

@@ -0,0 +1,223 @@
+import type { ArchoraConfig } from '../config/frontScopeConfig';
+
+export interface BuildInitialArchoraConfigInput {
+  files: readonly string[];
+  packageJsonText?: string;
+}
+
+export interface InitialArchoraConfigResult {
+  config: ArchoraConfig;
+  detected: InitialArchoraDetection[];
+}
+
+export type InitialArchoraDetection =
+  | 'vite'
+  | 'next'
+  | 'nuxt'
+  | 'sveltekit'
+  | 'workspace-packages'
+  | 'generated-openapi';
+
+const DEFAULT_IGNORES = [
+  'dist/**',
+  'build/**',
+  'coverage/**',
+  '.next/**',
+  '.nuxt/**',
+  '.svelte-kit/**',
+];
+
+const ENTRY_CANDIDATES = [
+  'src/main.ts',
+  'src/main.tsx',
+  'src/main.js',
+  'src/main.jsx',
+  'src/App.tsx',
+  'src/App.jsx',
+  'src/app/layout.tsx',
+  'src/app/page.tsx',
+  'src/pages/_app.tsx',
+  'src/pages/index.tsx',
+  'src/routes/+layout.svelte',
+  'src/routes/+page.svelte',
+  'app/layout.tsx',
+  'app/page.tsx',
+  'pages/_app.tsx',
+  'pages/index.tsx',
+  'pages/index.vue',
+];
+
+export function buildInitialArchoraConfig(
+  input: BuildInitialArchoraConfigInput,
+): InitialArchoraConfigResult {
+  const files = normalizeFiles(input.files);
+  const fileSet = new Set(files);
+  const packageJson = parsePackageJson(input.packageJsonText);
+  const detected = detectProjectShape(fileSet, packageJson);
+
+  const config: ArchoraConfig = {
+    entryPoints: pickEntryPoints(files, fileSet, detected),
+    ignore: DEFAULT_IGNORES,
+    signals: {
+      insightLimit: 6,
+      minInsightSeverity: 'medium',
+      minInsightConfidence: 'medium',
+    },
+  };
+
+  if (detected.includes('generated-openapi')) {
+    config.analysis = {
+      generated: {
+        mode: 'classify',
+        presets: ['openapi', 'generated-folder'],
+      },
+    };
+  }
+
+  if (detected.includes('workspace-packages')) {
+    config.contracts = {
+      boundaries: [
+        {
+          name: 'packages-through-public-api',
+          from: 'packages/*/src/**',
+          to: 'packages/*/src/**',
+          mode: 'must-not',
+          crossInstance: true,
+          except: ['packages/*/src/index.*'],
+          severity: 'warning',
+          description: 'Workspace packages should consume sibling packages through public APIs.',
+        },
+      ],
+      budgets: [
+        {
+          name: 'package-entry-fanout',
+          module: 'packages/*/src/index.*',
+          maxFanOut: 12,
+          severity: 'warning',
+          description: 'Package entry points should stay narrow enough to review.',
+        },
+      ],
+    };
+  }
+
+  return { config, detected };
+}
+
+export function buildInitialArchoraConfigJson(
+  input: BuildInitialArchoraConfigInput,
+  indent = 2,
+): string {
+  return `${JSON.stringify(buildInitialArchoraConfig(input).config, null, indent)}\n`;
+}
+
+function normalizeFiles(files: readonly string[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const raw of files) {
+    const rel = raw.replace(/\\/g, '/').replace(/^\.?\//u, '');
+    if (!rel || seen.has(rel)) continue;
+    seen.add(rel);
+    out.push(rel);
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+
+function parsePackageJson(text: string | undefined): Record<string, unknown> | null {
+  if (!text) return null;
+  try {
+    const parsed = JSON.parse(text) as unknown;
+    return parsed && typeof parsed === 'object' ? (parsed as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+function detectProjectShape(
+  files: ReadonlySet<string>,
+  packageJson: Record<string, unknown> | null,
+): InitialArchoraDetection[] {
+  const deps = collectDependencies(packageJson);
+  const detected: InitialArchoraDetection[] = [];
+
+  if (deps.has('vite') || files.has('vite.config.ts') || files.has('vite.config.js')) {
+    detected.push('vite');
+  }
+  if (deps.has('next') || files.has('next.config.js') || files.has('next.config.ts')) {
+    detected.push('next');
+  }
+  if (deps.has('nuxt') || files.has('nuxt.config.ts') || files.has('nuxt.config.js')) {
+    detected.push('nuxt');
+  }
+  if (deps.has('@sveltejs/kit') || files.has('svelte.config.js') || files.has('svelte.config.ts')) {
+    detected.push('sveltekit');
+  }
+  if (hasWorkspacePackages(files, packageJson)) {
+    detected.push('workspace-packages');
+  }
+  if ([...files].some(isGeneratedApiPath)) {
+    detected.push('generated-openapi');
+  }
+
+  return detected;
+}
+
+function collectDependencies(packageJson: Record<string, unknown> | null): Set<string> {
+  const deps = new Set<string>();
+  for (const key of ['dependencies', 'devDependencies', 'peerDependencies']) {
+    const block = packageJson?.[key];
+    if (!block || typeof block !== 'object') continue;
+    for (const name of Object.keys(block as Record<string, unknown>)) deps.add(name);
+  }
+  return deps;
+}
+
+function hasWorkspacePackages(
+  files: ReadonlySet<string>,
+  packageJson: Record<string, unknown> | null,
+): boolean {
+  const workspaces = packageJson?.['workspaces'];
+  const hasWorkspaceField =
+    Array.isArray(workspaces) ||
+    Boolean(
+      workspaces &&
+      typeof workspaces === 'object' &&
+      Array.isArray((workspaces as Record<string, unknown>)['packages']),
+    );
+  if (!hasWorkspaceField) return false;
+  return [...files].some((file) => /^packages\/[^/]+\/src\/index\.[cm]?[jt]sx?$/u.test(file));
+}
+
+function pickEntryPoints(
+  files: readonly string[],
+  fileSet: ReadonlySet<string>,
+  detected: readonly InitialArchoraDetection[],
+): string[] {
+  const entries: string[] = [];
+  for (const candidate of ENTRY_CANDIDATES) {
+    if (fileSet.has(candidate)) entries.push(candidate);
+  }
+  if (detected.includes('workspace-packages')) {
+    entries.push(
+      ...files.filter((file) => /^packages\/[^/]+\/src\/index\.[cm]?[jt]sx?$/u.test(file)),
+    );
+  }
+  return dedupe(entries);
+}
+
+function isGeneratedApiPath(file: string): boolean {
+  return (
+    /(^|\/)(openapi|api-generated|swagger|__generated__|generated)\//u.test(file) ||
+    /\.(gen|generated)\.[cm]?[jt]sx?$/u.test(file)
+  );
+}
+
+function dedupe(values: readonly string[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const value of values) {
+    if (seen.has(value)) continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}

package/src/config/__tests__/frontScopeConfig.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, it } from 'vitest';
+import {
+  loadArchoraConfig,
+  loadArchoraConfigWithDiagnostics,
+  resolveGeneratedPatterns,
+  GENERATED_PRESETS,
+} from '../frontScopeConfig';
+import type { FileSource } from '../../analyzer/fileSource';
+
+describe('frontScopeConfig analysis.generated', () => {
+  it('parses kebab mode + patterns + presets and dedupes', async () => {
+    const cfg = await loadArchoraConfig(
+      mockSource({
+        '.archora.json': JSON.stringify({
+          analysis: {
+            generated: {
+              mode: 'classify',
+              patterns: ['src/recruit/openapi/**', '  ', '**/openapi/**'],
+              presets: ['openapi', 'unknown-preset', 'vendor'],
+            },
+          },
+        }),
+      }),
+    );
+
+    expect(cfg.analysis?.generated?.mode).toBe('classify');
+    expect(cfg.analysis?.generated?.patterns).toEqual(['src/recruit/openapi/**', '**/openapi/**']);
+    expect(cfg.analysis?.generated?.presets).toEqual(['openapi', 'vendor']);
+  });
+
+  it('accepts the legacy `classifyAsGenerated` mode + `paths` shape from the Settings UI snippet', async () => {
+    const cfg = await loadArchoraConfig(
+      mockSource({
+        '.archora.json': JSON.stringify({
+          analysis: {
+            generated: {
+              mode: 'classifyAsGenerated',
+              paths: ['src/api-generated/**'],
+            },
+          },
+        }),
+      }),
+    );
+
+    expect(cfg.analysis?.generated?.mode).toBe('classify');
+    expect(cfg.analysis?.generated?.patterns).toEqual(['src/api-generated/**']);
+  });
+
+  it('drops the policy when neither patterns nor presets are present', async () => {
+    const cfg = await loadArchoraConfig(
+      mockSource({
+        '.archora.json': JSON.stringify({
+          analysis: { generated: { mode: 'classify' } },
+        }),
+      }),
+    );
+    expect(cfg.analysis).toBeUndefined();
+  });
+
+  it('returns diagnostics for invalid config fields without throwing', async () => {
+    const result = await loadArchoraConfigWithDiagnostics(
+      mockSource({
+        '.archora.json': JSON.stringify({
+          unknownField: true,
+          ignore: 'dist/**',
+          analysis: { generated: { mode: 'classify', presets: ['bad-preset'] } },
+          contracts: { budgets: [{ name: 'shared-budget', module: 'src/shared/**' }] },
+        }),
+      }),
+    );
+
+    expect(result.config.ignore).toBeUndefined();
+    expect(result.file).toBe('.archora.json');
+    expect(result.diagnostics.map((diagnostic) => diagnostic.path)).toEqual(
+      expect.arrayContaining([
+        '$.unknownField',
+        '$.ignore',
+        '$.analysis.generated.presets[0]',
+        '$.contracts.budgets[0]',
+      ]),
+    );
+  });
+
+  it('parses signal suppressions from project config', async () => {
+    const cfg = await loadArchoraConfig(
+      mockSource({
+        '.archora.json': JSON.stringify({
+          signals: {
+            insightLimit: 4,
+            minInsightSeverity: 'high',
+            minInsightConfidence: 'high',
+            suppressions: [
+              {
+                stableKey: 'contract:shared-boundary',
+                reason: 'Accepted until shared API extraction lands.',
+                scope: 'module',
+                moduleId: 'src/shared/api/client.ts',
+                createdAt: '2026-05-22T00:00:00.000Z',
+                expiresAt: '2026-06-22T00:00:00.000Z',
+              },
+            ],
+          },
+        }),
+      }),
+    );
+
+    expect(cfg.signals?.suppressions?.[0]).toMatchObject({
+      stableKey: 'contract:shared-boundary',
+      reason: 'Accepted until shared API extraction lands.',
+      scope: 'module',
+      moduleId: 'src/shared/api/client.ts',
+    });
+    expect(cfg.signals).toMatchObject({
+      insightLimit: 4,
+      minInsightSeverity: 'high',
+      minInsightConfidence: 'high',
+    });
+  });
+
+  it('parses architecture budget thresholds from project config', async () => {
+    const cfg = await loadArchoraConfig(
+      mockSource({
+        '.archora.json': JSON.stringify({
+          architectureBudget: {
+            maxDebtScore: 35,
+            maxCycles: 0,
+            maxCriticalSignals: 0,
+            maxContractErrors: 0,
+            maxHotspotGrowth: 2,
+          },
+        }),
+      }),
+    );
+
+    expect(cfg.architectureBudget).toEqual({
+      maxDebtScore: 35,
+      maxCycles: 0,
+      maxCriticalSignals: 0,
+      maxContractErrors: 0,
+      maxHotspotGrowth: 2,
+    });
+  });
+
+  it('reports invalid JSON as a config diagnostic', async () => {
+    const result = await loadArchoraConfigWithDiagnostics(
+      mockSource({
+        '.archora.json': '{',
+      }),
+    );
+
+    expect(result.config).toEqual({});
+    expect(result.file).toBe('.archora.json');
+    expect(result.diagnostics[0]).toMatchObject({
+      file: '.archora.json',
+      path: '$',
+      severity: 'error',
+    });
+  });
+
+  it('reports absent rules config without diagnostics', async () => {
+    const result = await loadArchoraConfigWithDiagnostics(mockSource({}));
+
+    expect(result.config).toEqual({});
+    expect(result.file).toBeNull();
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it('expands presets in declaration order, user patterns first', () => {
+    const out = resolveGeneratedPatterns({
+      mode: 'classify',
+      patterns: ['src/recruit/openapi/**'],
+      presets: ['openapi', 'generated-folder'],
+    });
+    expect(out[0]).toBe('src/recruit/openapi/**');
+    for (const p of GENERATED_PRESETS.openapi) expect(out).toContain(p);
+    for (const p of GENERATED_PRESETS['generated-folder']) expect(out).toContain(p);
+  });
+});
+
+function mockSource(files: Record<string, string>): FileSource {
+  return {
+    rootPath: '/repo',
+    list: async () => Object.keys(files),
+    read: async (p) => files[p] ?? '',
+    exists: async (p) => p in files,
+  };
+}