@ai-sdlc/orchestrator 0.6.0 → 0.9.0

package/dist/admission-score.js

@@ -5,7 +5,8 @@
  * Extracted from dogfood/scripts/ppa-score.ts for reuse across CLI
  * scripts and workflows.
  */
-import { computePriority, } from './priority.js';
+import { computeAdmissionComposite } from './admission-composite.js';
+import { computePillarBreakdown } from './pillar-breakdown.js';
 // ── Mapping ──────────────────────────────────────────────────────────
 /**
  * Map GitHub issue fields to PPA PriorityInput dimensions.
@@ -20,14 +21,31 @@ import { computePriority, } from './priority.js';
 export function mapIssueToPriorityInput(input) {
     const labels = input.labels;
     const assoc = input.authorAssociation ?? 'NONE';
+    const backlog = input.backlogContext;
+    // ── Backlog status veto ─────────────────────────────────────
+    // Drafts aren't ready to admit; orchestrator should ignore them.
+    if (backlog?.status === 'Draft') {
+        return {
+            itemId: `#${input.issueNumber}`,
+            title: input.title,
+            description: input.body ?? '',
+            labels,
+            soulAlignment: 0,
+        };
+    }
     // ── Trust-based signal boosting ────────────────────────────────
     // Trusted sources (project team) get baseline conviction and demand.
     // Untrusted sources need external validation (reactions, comments).
     const isTrusted = assoc === 'OWNER' || assoc === 'MEMBER' || assoc === 'COLLABORATOR';
     const isContributor = assoc === 'CONTRIBUTOR';
-    // ── Complexity from issue body ───────────────────────────────
+    // ── Complexity from issue body, AC count, or backlog context ─
     const complexityMatch = input.body?.match(/###?\s*Complexity\s*\n+\s*(\d+)/i);
-    const complexity = complexityMatch ? Number(complexityMatch[1]) : undefined;
+    let complexity = complexityMatch ? Number(complexityMatch[1]) : undefined;
+    // Backlog tasks rarely include a `### Complexity` header — fall back to AC count
+    // (each AC is roughly one logical unit; clamp at 10).
+    if (complexity === undefined && backlog?.acceptanceCriteriaCount !== undefined) {
+        complexity = Math.min(10, Math.max(1, Math.ceil(backlog.acceptanceCriteriaCount * 1.2)));
+    }
     // ── Bug severity from labels ─────────────────────────────────
     let bugSeverity;
     if (labels.includes('critical') || labels.includes('P0'))
@@ -44,6 +62,12 @@ export function mapIssueToPriorityInput(input) {
         soulAlignment = 0.85;
     if (labels.includes('spec') || labels.includes('rfc'))
         soulAlignment = 0.9;
+    // Backlog-specific labels — RFC process work directly serves project mission;
+    // tech-debt is operationally important but not mission-defining.
+    if (labels.includes('rfc-process') || labels.includes('architecture'))
+        soulAlignment = 0.85;
+    if (labels.includes('tech-debt') && soulAlignment < 0.55)
+        soulAlignment = 0.55;
     // Trusted authors get a soul alignment floor — they know the project mission
     if (isTrusted && soulAlignment < 0.6)
         soulAlignment = 0.6;
@@ -64,13 +88,18 @@ export function mapIssueToPriorityInput(input) {
     // Contributor: moderate (proven track record)
     // ai-eligible label: explicit signal
     // Default: low (needs validation)
-    const builderConviction = labels.includes('ai-eligible')
+    let builderConviction = labels.includes('ai-eligible')
         ? 0.8
         : isTrusted
             ? 0.8
             : isContributor
                 ? 0.6
                 : 0.4;
+    // Backlog tasks blocked by other work get a conviction penalty — the team
+    // can't confidently dispatch them until upstream lands.
+    if (backlog?.dependencyCount && backlog.dependencyCount > 0) {
+        builderConviction = Math.max(0.2, builderConviction - 0.3);
+    }
     // ── Age → competitive drift ──────────────────────────────────
     const ageMs = Date.now() - new Date(input.createdAt).getTime();
     const ageDays = ageMs / (1000 * 60 * 60 * 24);
@@ -85,6 +114,15 @@ export function mapIssueToPriorityInput(input) {
             soulAlignment: 0, // veto
         };
     }
+    // ── Explicit priority — labels first, then backlog frontmatter ──
+    let explicitPriority;
+    if (labels.includes('high'))
+        explicitPriority = 0.8;
+    else if (labels.includes('low'))
+        explicitPriority = 0.2;
+    else if (backlog?.priority) {
+        explicitPriority = mapBacklogPriorityToScalar(backlog.priority);
+    }
     return {
         itemId: `#${input.issueNumber}`,
         title: input.title,
@@ -98,9 +136,24 @@ export function mapIssueToPriorityInput(input) {
         complexity,
         competitiveDrift,
         teamConsensus,
-        explicitPriority: labels.includes('high') ? 0.8 : labels.includes('low') ? 0.2 : undefined,
+        explicitPriority,
     };
 }
+/** Map backlog frontmatter priority string to a scalar in [0,1]. */
+function mapBacklogPriorityToScalar(p) {
+    switch (p) {
+        case 'critical':
+            return 1.0;
+        case 'high':
+            return 0.8;
+        case 'medium':
+            return 0.5;
+        case 'low':
+            return 0.2;
+        default:
+            return 0.5;
+    }
+}
 // ── Suggestions ──────────────────────────────────────────────────────
 function generateSuggestions(input, score) {
     const suggestions = [];
@@ -129,14 +182,22 @@ function generateSuggestions(input, score) {
 }
 // ── Public API ───────────────────────────────────────────────────────
 /**
- * Score a GitHub issue for pipeline admission using the Product Priority Algorithm.
+ * Score a GitHub issue for pipeline admission using the RFC-0008 §A.6
+ * admission-subset composite.
  *
- * Returns whether the issue is admitted (score and confidence above thresholds)
- * along with the full score and, if rejected, suggestions for improvement.
+ *   P_admission = SA × D-pi_adjusted × ER × (1 + HC)
+ *
+ * M-phi, E-tau, C-kappa are deferred to runtime scoring — they apply
+ * when an admitted issue is picked up for execution, not at the gate.
+ *
+ * Returns whether the issue is admitted (score and confidence above
+ * thresholds) along with the full score and, if rejected, suggestions
+ * for improvement.
  */
-export function scoreIssueForAdmission(input, thresholds, priorityConfig) {
-    const priorityInput = mapIssueToPriorityInput(input);
-    const score = computePriority(priorityInput, priorityConfig);
+export function scoreIssueForAdmission(input, thresholds, priorityConfig, options) {
+    const composite = computeAdmissionComposite(input, priorityConfig, options);
+    const { score } = composite;
+    const pillarBreakdown = computePillarBreakdown(composite);
     const scorePasses = score.composite >= thresholds.minimumScore;
     const confidencePasses = score.confidence >= thresholds.minimumConfidence;
     const admitted = scorePasses && confidencePasses;
@@ -145,6 +206,7 @@ export function scoreIssueForAdmission(input, thresholds, priorityConfig) {
             admitted: true,
             score,
             reason: `Score ${score.composite.toFixed(4)} meets threshold ${thresholds.minimumScore} with ${(score.confidence * 100).toFixed(0)}% confidence`,
+            pillarBreakdown,
         };
     }
     const reasons = [];
@@ -159,6 +221,17 @@ export function scoreIssueForAdmission(input, thresholds, priorityConfig) {
         score,
         reason: `Not admitted: ${reasons.join('; ')}`,
         suggestions: generateSuggestions(input, score),
+        pillarBreakdown,
     };
 }
+/** Map backlog frontmatter priority string to the typed BacklogContext shape. */
+export function normalizeBacklogPriority(p) {
+    if (!p)
+        return undefined;
+    const lower = p.toLowerCase().trim();
+    if (lower === 'critical' || lower === 'high' || lower === 'medium' || lower === 'low') {
+        return lower;
+    }
+    return undefined;
+}
 //# sourceMappingURL=admission-score.js.map

package/dist/analysis/analyzer.js

@@ -30,8 +30,9 @@ export async function analyzeCodebase(options) {
     const moduleGraph = await buildModuleGraph(files, modules, options.repoPath);
     // Step 5: Detect architectural patterns
     const architecturalPatterns = detectPatterns(files, modules);
-    // Step 6: Detect conventions
-    const conventions = detectConventions(files);
+    // Step 6: Detect conventions (project-config-aware: package.json, vite.config.*,
+    // tsconfig.json, jsconfig.json, webpack.config.* — see AISDLC-80).
+    const conventions = await detectConventions(files, { repoPath: options.repoPath });
     // Step 7: Analyze hotspots
     const hotspots = await analyzeHotspots(options.repoPath, files, importsByFile, {
         historyDays,

package/dist/analysis/convention-detector.d.ts

@@ -1,9 +1,92 @@
 /**
  * Detect coding conventions: naming style, test organization, import style.
+ *
+ * The detector accepts an optional `repoPath` so it can read project-level
+ * configuration (`package.json`, `vite.config.{js,ts}`, `tsconfig.json`,
+ * `jsconfig.json`, `webpack.config.*`) to interpret the file list more
+ * accurately. When `repoPath` is omitted the detector falls back to a pure
+ * file-name analysis (the original v1 behaviour).
+ *
+ * Three classes of false-positives motivated the project-config plumbing
+ * (AISDLC-80):
+ *
+ *  1. React projects mix PascalCase (components) with camelCase (hooks/stores
+ *     and plain modules) — the v1 detector flagged this as `mixed`. With
+ *     `package.json` `dependencies.react` visible we treat the dual-pattern
+ *     case as the expected React convention.
+ *  2. Many repos host tests in multiple directories (`tests/`, `tests/e2e/`,
+ *     `src/tests/`, `cypress/`, ...) plus collocated `*.test.*`. The v1
+ *     detector picked one bucket and called it `mixed` when the proportions
+ *     were close. We now enumerate the FULL set of locations.
+ *  3. Vite / TS / webpack path aliases (`@components`, `@engine`, ...) were
+ *     classified as external imports because the v1 detector never read the
+ *     alias maps. We now parse the alias map from each known config file and
+ *     report alias usage as its own bucket.
  */
 import type { FileInfo, DetectedConvention } from './types.js';
 /**
- * Detect coding conventions from the file list.
+ * Each entry describes ONE place tests live in the repo. We enumerate ALL of
+ * them rather than flatten to a single label — a repo with `tests/`,
+ * `tests/e2e/`, `src/tests/` and a few collocated `*.test.*` files is reported
+ * with all four buckets visible (AISDLC-80).
  */
-export declare function detectConventions(files: FileInfo[]): DetectedConvention[];
+export interface TestLocationSummary {
+    /** Stable label for the bucket (e.g. `__tests__/`, `tests/e2e/`, `co-located`). */
+    label: string;
+    /** Number of test files matched against this bucket. */
+    count: number;
+    /** Up to three example file paths from this bucket. */
+    examples: string[];
+}
+/**
+ * Classify every test file found into ALL the locations it actually lives,
+ * preserving the multi-directory reality of real projects. Returns the
+ * complete set sorted by file count (descending) with examples for each.
+ */
+export declare function enumerateTestLocations(files: FileInfo[]): TestLocationSummary[];
+/** Map of alias prefix (e.g. `@components`) → resolved target glob. */
+export type PathAliasMap = Record<string, string>;
+/**
+ * Parse `compilerOptions.paths` from a `tsconfig.json` / `jsconfig.json`.
+ * The TS config format maps `"@components/*": ["src/components/*"]` — we
+ * normalise to `@components` → `src/components/*`.
+ */
+export declare function parseTsConfigAliases(content: string): PathAliasMap;
+/**
+ * Extract `resolve.alias` (object literal form) from a Vite or webpack config
+ * file. We use a regex rather than a full JS parser because the contents are
+ * config files written in a small, well-known shape — the v1 detector's
+ * "regex over AST" tradeoff carries forward.
+ *
+ * Recognises both:
+ *   resolve: { alias: { '@components': path.resolve(__dirname, 'src/components') } }
+ *   alias: { '@engine': '/abs/path' }
+ */
+export declare function parseViteOrWebpackAliases(content: string): PathAliasMap;
+/**
+ * Read every alias source we know about and merge into a single map. Sources
+ * are read in parallel; later sources take precedence if there is overlap.
+ */
+export declare function loadProjectAliases(repoPath: string): Promise<PathAliasMap>;
+/**
+ * Read `package.json` and decide whether this is a React project. Looks at
+ * `dependencies` AND `devDependencies` because Vite-driven SPAs sometimes
+ * declare React as a dev dep via templates.
+ */
+export declare function detectReactProject(repoPath: string): Promise<boolean>;
+export interface DetectConventionsOptions {
+    /**
+     * Absolute path to the repo root. When provided the detector reads project
+     * configs (`package.json`, vite/tsconfig/jsconfig/webpack) for context-aware
+     * decisions. Without it the detector falls back to pure file-name analysis.
+     */
+    repoPath?: string;
+}
+/**
+ * Detect coding conventions from the file list. When `options.repoPath` is
+ * supplied the detector additionally reads project-level configuration to
+ * suppress the three classes of false-positives described at the top of this
+ * file (AISDLC-80).
+ */
+export declare function detectConventions(files: FileInfo[], options?: DetectConventionsOptions): Promise<DetectedConvention[]>;
 //# sourceMappingURL=convention-detector.d.ts.map