@ai-sdlc/orchestrator 0.5.0 → 0.9.0

package/dist/admission-score.js

@@ -0,0 +1,237 @@
+/**
+ * Issue admission scoring — maps GitHub issue fields to PPA dimensions
+ * and determines whether an issue should enter the pipeline.
+ *
+ * Extracted from dogfood/scripts/ppa-score.ts for reuse across CLI
+ * scripts and workflows.
+ */
+import { computeAdmissionComposite } from './admission-composite.js';
+import { computePillarBreakdown } from './pillar-breakdown.js';
+// ── Mapping ──────────────────────────────────────────────────────────
+/**
+ * Map GitHub issue fields to PPA PriorityInput dimensions.
+ *
+ * Heuristics (ported from dogfood/scripts/ppa-score.ts):
+ * - Labels → bug severity, soul alignment hints, builder conviction
+ * - Reactions → team consensus, customer request count
+ * - Comments → demand signal
+ * - Body complexity section → complexity score
+ * - Issue age → competitive drift
+ */
+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, AC count, or backlog context ─
+    const complexityMatch = input.body?.match(/###?\s*Complexity\s*\n+\s*(\d+)/i);
+    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'))
+        bugSeverity = 5;
+    else if (labels.includes('bug'))
+        bugSeverity = 3;
+    // ── Soul alignment heuristic from labels ─────────────────────
+    let soulAlignment = 0.5;
+    if (labels.includes('security') || labels.includes('security-triage'))
+        soulAlignment = 0.7;
+    if (labels.includes('enhancement'))
+        soulAlignment = 0.6;
+    if (labels.includes('governance') || labels.includes('compliance'))
+        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;
+    // ── Reactions → demand / consensus ───────────────────────────
+    const reactionConsensus = Math.min(1, input.reactionCount / 5);
+    // Trusted sources carry implicit team consensus
+    const teamConsensus = isTrusted ? Math.max(0.5, reactionConsensus) : reactionConsensus;
+    // ── Comment count → demand signal ────────────────────────────
+    const commentDemand = Math.min(1, input.commentCount / 5);
+    // Trusted sources filing an issue IS demand — they wouldn't file it otherwise
+    const demandSignal = isTrusted
+        ? Math.max(0.4, commentDemand)
+        : isContributor
+            ? Math.max(0.2, commentDemand)
+            : commentDemand;
+    // ── Builder conviction ─────────────────────────────────────────
+    // Trusted: high conviction (they're the builders)
+    // Contributor: moderate (proven track record)
+    // ai-eligible label: explicit signal
+    // Default: low (needs validation)
+    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);
+    const competitiveDrift = Math.min(1, Math.max(0, (ageDays - 30) / 180));
+    // ── Security-rejected veto ───────────────────────────────────
+    if (labels.includes('security-rejected')) {
+        return {
+            itemId: `#${input.issueNumber}`,
+            title: input.title,
+            description: input.body ?? '',
+            labels,
+            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,
+        description: input.body ?? '',
+        labels,
+        soulAlignment,
+        bugSeverity,
+        customerRequestCount: input.reactionCount,
+        demandSignal,
+        builderConviction,
+        complexity,
+        competitiveDrift,
+        teamConsensus,
+        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 = [];
+    const d = score.dimensions;
+    if (score.confidence < 0.2) {
+        suggestions.push('Add more detail to improve scoring confidence (complexity, acceptance criteria, labels)');
+    }
+    if (!input.body?.match(/###?\s*Complexity\s*\n/i)) {
+        suggestions.push('Add a `### Complexity` section with a score from 1-10');
+    }
+    if (!input.body?.match(/###?\s*Acceptance Criteria/i)) {
+        suggestions.push('Add an `### Acceptance Criteria` section with testable criteria');
+    }
+    if (input.body.length < 50) {
+        suggestions.push('Provide a more detailed description of the problem or feature');
+    }
+    const assoc = input.authorAssociation ?? 'NONE';
+    const isTrusted = assoc === 'OWNER' || assoc === 'MEMBER' || assoc === 'COLLABORATOR';
+    if (d.demandPressure < 0.3 && !isTrusted) {
+        suggestions.push('Low demand signal — add reactions or comments to show interest');
+    }
+    if (d.soulAlignment < 0.5) {
+        suggestions.push('Add labels that indicate alignment with the project mission (e.g., governance, spec, security)');
+    }
+    return suggestions;
+}
+// ── Public API ───────────────────────────────────────────────────────
+/**
+ * Score a GitHub issue for pipeline admission using the RFC-0008 §A.6
+ * admission-subset composite.
+ *
+ *   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, 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;
+    if (admitted) {
+        return {
+            admitted: true,
+            score,
+            reason: `Score ${score.composite.toFixed(4)} meets threshold ${thresholds.minimumScore} with ${(score.confidence * 100).toFixed(0)}% confidence`,
+            pillarBreakdown,
+        };
+    }
+    const reasons = [];
+    if (!scorePasses) {
+        reasons.push(`score ${score.composite.toFixed(4)} below minimum ${thresholds.minimumScore}`);
+    }
+    if (!confidencePasses) {
+        reasons.push(`confidence ${(score.confidence * 100).toFixed(0)}% below minimum ${(thresholds.minimumConfidence * 100).toFixed(0)}%`);
+    }
+    return {
+        admitted: false,
+        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