@ai-sdlc/orchestrator 0.6.0 → 0.9.0

package/dist/analysis/hotspot-analyzer.js

@@ -5,6 +5,7 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { DEFAULT_GIT_HISTORY_DAYS, DEFAULT_HOTSPOT_THRESHOLD } from '../defaults.js';
+import { cleanGitEnv } from '../runtime/git-env.js';
 const execFileAsync = promisify(execFile);
 /**
  * Run `git log` to get file churn data.
@@ -12,7 +13,8 @@ const execFileAsync = promisify(execFile);
 export async function getFileChurn(repoPath, historyDays = DEFAULT_GIT_HISTORY_DAYS) {
     try {
         const since = `${historyDays} days ago`;
-        const { stdout } = await execFileAsync('git', ['log', '--format=', '--name-only', `--since=${since}`], { cwd: repoPath, maxBuffer: 10 * 1024 * 1024 });
+        // cleanGitEnv() prevents leaked GIT_DIR from binding to a parent repo (AISDLC-72).
+        const { stdout } = await execFileAsync('git', ['log', '--format=', '--name-only', `--since=${since}`], { cwd: repoPath, maxBuffer: 10 * 1024 * 1024, env: cleanGitEnv() });
         const counts = new Map();
         for (const line of stdout.split('\n')) {
             const trimmed = line.trim();

package/dist/analysis/index.d.ts

@@ -4,10 +4,11 @@
 export type { CodebaseProfile, CodebaseContext, Hotspot, ArchitecturalPattern, DetectedConvention, ModuleInfo, ModuleGraph, DependencyEdge, AnalyzerOptions, FileInfo, ImportStatement, } from './types.js';
 export { walkFiles, detectModules } from './file-walker.js';
 export { parseImports, buildModuleGraph } from './dependency-parser.js';
-export { detectConventions } from './convention-detector.js';
+export { detectConventions, detectReactProject, loadProjectAliases, parseTsConfigAliases, parseViteOrWebpackAliases, enumerateTestLocations, type DetectConventionsOptions, type PathAliasMap, type TestLocationSummary, } from './convention-detector.js';
 export { detectPatterns } from './pattern-detector.js';
 export { analyzeHotspots } from './hotspot-analyzer.js';
 export { computeComplexityScore } from './complexity-scorer.js';
 export { analyzeCodebase } from './analyzer.js';
 export { buildCodebaseContext, formatContextForPrompt } from './context-builder.js';
+export { analyzeDiff, extractChangedFiles, type DiffFinding, type DiffAnalysisResult, } from './diff-analyzer.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/analysis/index.js

@@ -3,10 +3,11 @@
  */
 export { walkFiles, detectModules } from './file-walker.js';
 export { parseImports, buildModuleGraph } from './dependency-parser.js';
-export { detectConventions } from './convention-detector.js';
+export { detectConventions, detectReactProject, loadProjectAliases, parseTsConfigAliases, parseViteOrWebpackAliases, enumerateTestLocations, } from './convention-detector.js';
 export { detectPatterns } from './pattern-detector.js';
 export { analyzeHotspots } from './hotspot-analyzer.js';
 export { computeComplexityScore } from './complexity-scorer.js';
 export { analyzeCodebase } from './analyzer.js';
 export { buildCodebaseContext, formatContextForPrompt } from './context-builder.js';
+export { analyzeDiff, extractChangedFiles, } from './diff-analyzer.js';
 //# sourceMappingURL=index.js.map

package/dist/artifacts/index.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Artifact directory module per RFC-0010 §16. Provides:
+ *   - Heartbeat writer (state.json updated every 60s; stale > 5 min surfaces in cli-status)
+ *   - Event-stream emitter (_events.jsonl JSONL append-only)
+ *   - Schema-conformant artifact validator (Q7)
+ *   - Resumability helper (read state.json to determine next stage)
+ */
+export declare const HEARTBEAT_INTERVAL_MS = 60000;
+export declare const HEARTBEAT_STALE_MS: number;
+export type StageStatus = 'pending' | 'running' | 'success' | 'failure' | 'skipped';
+export interface RuntimeState {
+    issueId: string;
+    currentStage: string;
+    startedAt: string;
+    lastHeartbeat: string;
+    status: StageStatus;
+    resolvedHarness?: string;
+    resolvedModel?: string;
+    port?: number;
+    worktreePath?: string;
+    databaseBranchKeys?: Record<string, string>;
+}
+export interface ArtifactEvent {
+    type: string;
+    timestamp: string;
+    issueId?: string;
+    stage?: string;
+    [key: string]: unknown;
+}
+export declare class StateWriter {
+    readonly artifactsDir: string;
+    readonly issueId: string;
+    private readonly statePath;
+    private heartbeatTimer;
+    constructor(artifactsDir: string, issueId: string);
+    writeState(state: RuntimeState): Promise<void>;
+    readState(): Promise<RuntimeState | null>;
+    /**
+     * Start emitting heartbeats. The caller's `produce` function returns the latest
+     * RuntimeState snapshot to persist; the writer schedules persistence every
+     * HEARTBEAT_INTERVAL_MS. Returns a stop function.
+     */
+    startHeartbeat(produce: () => RuntimeState): () => void;
+    /**
+     * Returns true when the persisted state's lastHeartbeat is older than HEARTBEAT_STALE_MS.
+     * Used by cli-status to flag hung agents.
+     */
+    static isStale(state: RuntimeState, now?: Date): boolean;
+}
+/** Append a single event to $ARTIFACTS_DIR/_events.jsonl. Atomic per-line. */
+export declare function appendEvent(artifactsDir: string, event: ArtifactEvent): Promise<void>;
+export declare function readEvents(artifactsDir: string, options?: {
+    sinceTimestamp?: string;
+}): Promise<ArtifactEvent[]>;
+/**
+ * Atomic write: write to <path>.tmp, fsync (implicit via Node), rename. Per RFC §16.4
+ * the JSON artifact MUST NOT be visible to downstream stages until fully written.
+ */
+export declare function atomicWriteJson(path: string, data: unknown): Promise<void>;
+/**
+ * Read all per-issue runtime states under the artifacts dir. Used by cli-status --all
+ * to enumerate active branches per RFC §17.
+ */
+export declare function listActiveStates(artifactsDir: string): Promise<RuntimeState[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/artifacts/index.js

@@ -0,0 +1,142 @@
+/**
+ * Artifact directory module per RFC-0010 §16. Provides:
+ *   - Heartbeat writer (state.json updated every 60s; stale > 5 min surfaces in cli-status)
+ *   - Event-stream emitter (_events.jsonl JSONL append-only)
+ *   - Schema-conformant artifact validator (Q7)
+ *   - Resumability helper (read state.json to determine next stage)
+ */
+import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+export const HEARTBEAT_INTERVAL_MS = 60_000;
+export const HEARTBEAT_STALE_MS = 5 * 60_000;
+export class StateWriter {
+    artifactsDir;
+    issueId;
+    statePath;
+    heartbeatTimer = null;
+    constructor(artifactsDir, issueId) {
+        this.artifactsDir = artifactsDir;
+        this.issueId = issueId;
+        this.statePath = join(artifactsDir, issueId, 'state.json');
+    }
+    async writeState(state) {
+        await mkdir(dirname(this.statePath), { recursive: true });
+        state.lastHeartbeat = new Date().toISOString();
+        await writeFile(this.statePath, JSON.stringify(state, null, 2), 'utf8');
+    }
+    async readState() {
+        try {
+            const raw = await readFile(this.statePath, 'utf8');
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return null;
+            throw err;
+        }
+    }
+    /**
+     * Start emitting heartbeats. The caller's `produce` function returns the latest
+     * RuntimeState snapshot to persist; the writer schedules persistence every
+     * HEARTBEAT_INTERVAL_MS. Returns a stop function.
+     */
+    startHeartbeat(produce) {
+        if (this.heartbeatTimer)
+            throw new Error('Heartbeat already running');
+        const tick = async () => {
+            try {
+                const state = produce();
+                await this.writeState(state);
+            }
+            catch {
+                // Heartbeat failures are non-fatal; the stale-detection at read-time will surface them.
+            }
+        };
+        this.heartbeatTimer = setInterval(tick, HEARTBEAT_INTERVAL_MS);
+        return () => {
+            if (this.heartbeatTimer) {
+                clearInterval(this.heartbeatTimer);
+                this.heartbeatTimer = null;
+            }
+        };
+    }
+    /**
+     * Returns true when the persisted state's lastHeartbeat is older than HEARTBEAT_STALE_MS.
+     * Used by cli-status to flag hung agents.
+     */
+    static isStale(state, now = new Date()) {
+        const last = new Date(state.lastHeartbeat).getTime();
+        return now.getTime() - last > HEARTBEAT_STALE_MS;
+    }
+}
+/** Append a single event to $ARTIFACTS_DIR/_events.jsonl. Atomic per-line. */
+export async function appendEvent(artifactsDir, event) {
+    const path = join(artifactsDir, '_events.jsonl');
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, JSON.stringify(event) + '\n', 'utf8');
+}
+export async function readEvents(artifactsDir, options = {}) {
+    const path = join(artifactsDir, '_events.jsonl');
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const events = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            if (options.sinceTimestamp && e.timestamp < options.sinceTimestamp)
+                continue;
+            events.push(e);
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return events;
+}
+/**
+ * Atomic write: write to <path>.tmp, fsync (implicit via Node), rename. Per RFC §16.4
+ * the JSON artifact MUST NOT be visible to downstream stages until fully written.
+ */
+export async function atomicWriteJson(path, data) {
+    await mkdir(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+    await writeFile(tmp, JSON.stringify(data, null, 2), 'utf8');
+    const { rename } = await import('node:fs/promises');
+    await rename(tmp, path);
+}
+/**
+ * Read all per-issue runtime states under the artifacts dir. Used by cli-status --all
+ * to enumerate active branches per RFC §17.
+ */
+export async function listActiveStates(artifactsDir) {
+    const { readdir } = await import('node:fs/promises');
+    let entries;
+    try {
+        entries = await readdir(artifactsDir);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const states = [];
+    for (const entry of entries) {
+        if (entry.startsWith('_'))
+            continue; // skip _ledger, _events.jsonl, _classifier
+        const writer = new StateWriter(artifactsDir, entry);
+        const state = await writer.readState();
+        if (state)
+            states.push(state);
+    }
+    return states;
+}
+//# sourceMappingURL=index.js.map

package/dist/backlog-adapter.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Backlog.md tracker adapter for the admission composite.
+ *
+ * Backlog.md tasks are markdown files in `backlog/tasks/` (open) or
+ * `backlog/completed/` (archived). They carry YAML frontmatter
+ * (`id`, `title`, `status`, `priority`, `labels`, `references`,
+ * `created_date`, `updated_date`, `assignee`) plus a body that
+ * includes a `## Acceptance Criteria` checklist.
+ *
+ * This module:
+ *   1. Parses a task file into `BacklogTaskSnapshot`
+ *   2. Maps the snapshot onto `AdmissionInput` using the conventions
+ *      in the bug-fix doc (priority:p* / size:[SML] / track:* / etc.)
+ *   3. Emits `qualityFlags` for "Done with unchecked ACs" zombie closes
+ *
+ * The GitHub-shaped `mapIssueToPriorityInput` in `admission-score.ts`
+ * is left intact; the dispatch sits in `cli-admit`.
+ */
+import type { PriorityInput, QualityFlag } from '@ai-sdlc/reference';
+import { type AdmissionInput } from './admission-score.js';
+export interface BacklogAcceptanceCriterion {
+    index: number;
+    text: string;
+    checked: boolean;
+}
+export interface BacklogTaskSnapshot {
+    /** Canonical id from the YAML frontmatter, e.g. "AISDLC-42". */
+    id: string;
+    /** Numeric tail of the id, e.g. 42. */
+    numericId: number;
+    title: string;
+    description: string;
+    status: string;
+    priority: string | null;
+    labels: string[];
+    createdDate: string;
+    updatedDate: string;
+    createdBy?: string;
+    acceptanceCriteria: BacklogAcceptanceCriterion[];
+    references: string[];
+    /** Task IDs this task is blocked by (frontmatter `dependencies`). */
+    dependencies: string[];
+    /** Filesystem path the snapshot was read from. */
+    sourcePath?: string;
+}
+/**
+ * Parse a Backlog.md task markdown file into `BacklogTaskSnapshot`.
+ * Throws when the frontmatter is missing or malformed.
+ */
+export declare function parseBacklogTask(content: string, sourcePath?: string): BacklogTaskSnapshot;
+/**
+ * Resolve a Backlog task id ("AISDLC-42" or "task-42") to a snapshot
+ * by searching the `backlog/tasks/` and `backlog/completed/` directories
+ * under `backlogRoot` (typically the project root).
+ */
+export declare function loadBacklogTaskFromRoot(backlogRoot: string, id: string): BacklogTaskSnapshot | undefined;
+export interface BacklogMappingOptions {
+    /**
+     * Soul-tracks dictionary loaded from `.ai-sdlc/soul-tracks.json`,
+     * mapping `track:*` labels to a soul-alignment floor in [0, 1].
+     * Absent/empty → only `source:rfc` / `source:spec` /
+     * `governance` / `compliance` lift soulAlignment.
+     */
+    soulTracks?: Record<string, number>;
+    /**
+     * Maintainer logins for `OWNER` author-association mapping. When
+     * `createdBy` matches one of these, AdmissionInput.authorAssociation
+     * is set to OWNER (which feeds the trust-based signal floors in
+     * the existing GitHub mapper).
+     */
+    maintainers?: string[];
+}
+export interface BacklogAdmissionMapping {
+    /** Admission input shaped like the GitHub mapper output. */
+    input: AdmissionInput;
+    /**
+     * PriorityInput overrides derived from Backlog conventions
+     * (priority:p* / size:[SML] / track:* / source:* / AC progress).
+     * Pass these to `computeAdmissionComposite` via
+     * `AdmissionCompositeOptions.priorityInputOverrides` so they
+     * win over the GitHub-shaped label heuristic.
+     */
+    priorityInputOverrides: Partial<PriorityInput>;
+    /** Quality flags surfaced for renderers (zombie close, etc). */
+    qualityFlags: QualityFlag[];
+}
+/**
+ * Map a Backlog snapshot onto an `AdmissionInput` plus the
+ * `PriorityInput` overrides cli-admit feeds into the composite.
+ * The label-mapping table is the load-bearing piece; tests in
+ * `backlog-adapter.test.ts` pin each row.
+ */
+export declare function mapBacklogTaskToAdmissionInput(snap: BacklogTaskSnapshot, options?: BacklogMappingOptions): BacklogAdmissionMapping;
+/**
+ * Load `.ai-sdlc/soul-tracks.json` from the given config root.
+ * Format: `{ "track:enchantment": 0.85, "track:reflect": 0.85, ... }`.
+ * Missing file → empty object (caller falls back to DEFAULT_SOUL_TRACKS).
+ */
+export declare function loadSoulTracks(configRoot: string): Record<string, number>;
+/**
+ * Load `.ai-sdlc/maintainers.yaml` from the given config root.
+ *
+ * Accepts either of two shapes:
+ *
+ *   maintainers:
+ *     - alice
+ *     - bob
+ *
+ * or with metadata (only `login` is read, the rest is forward-looking):
+ *
+ *   maintainers:
+ *     - login: alice
+ *       role: owner
+ *     - login: bob
+ *
+ * A bare top-level list (`- alice\n- bob`) is also accepted. Returns
+ * an empty array on missing file or any parse error — callers can
+ * still pass `--maintainers` explicitly to override.
+ */
+export declare function loadMaintainers(configRoot: string): string[];
+//# sourceMappingURL=backlog-adapter.d.ts.map