@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/commands/lanes-autopilot.js

@@ -1,336 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { laneRunsHere } from "../lib/lanes/reconcile.js";
-import { listLaneReviews } from "../lib/lanes/reviews.js";
-import { readAllLanes } from "../lib/lanes/store.js";
-import { LANES_RUNS_REL } from "../lib/lanes/spawn.js";
-import { normalizeIsoTimestamp } from "../lib/lanes/timestamp.js";
-import { buildAutopilotMetricsReport, } from "../lib/lanes/autopilot-metrics.js";
-import { LanesError } from "../lib/lanes/errors.js";
-const OPERATOR_NUDGE_DEFECTS_REL = path.join("workspace", "lane-briefs", "operator-nudge-defects.jsonl");
-const JUNIORS_REL = path.join("workspace", "lane-briefs", "juniors.json");
-const DROPBOX_NAME = "dropbox";
-const RESUME_SUFFIX = ".resume.jsonl";
-function fail(error, message, details = {}) {
-    throw new LanesError(error, message, details);
-}
-function isObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function safeReadText(root, file, missingOk = false) {
-    let stat;
-    try {
-        stat = fs.lstatSync(file);
-    }
-    catch (err) {
-        if (missingOk && err.code === "ENOENT")
-            return null;
-        return fail("autopilot_metrics_input_unreadable", `Could not inspect report input: ${err instanceof Error ? err.message : String(err)}`, { path: file });
-    }
-    if (!stat.isFile() || stat.isSymbolicLink()) {
-        return fail("autopilot_metrics_input_invalid", "Report input must be a regular file", { path: file });
-    }
-    let realRoot;
-    let realFile;
-    try {
-        realRoot = fs.realpathSync(root);
-        realFile = fs.realpathSync(file);
-    }
-    catch (err) {
-        return fail("autopilot_metrics_input_unreadable", `Could not resolve report input: ${err instanceof Error ? err.message : String(err)}`, { path: file });
-    }
-    if (!realFile.startsWith(`${realRoot}${path.sep}`)) {
-        return fail("autopilot_metrics_input_invalid", "Report input must stay under the HQ root", { path: file });
-    }
-    try {
-        return fs.readFileSync(file, "utf8");
-    }
-    catch (err) {
-        return fail("autopilot_metrics_input_unreadable", `Could not read report input: ${err instanceof Error ? err.message : String(err)}`, { path: file });
-    }
-}
-function parseJsonObject(root, file) {
-    const raw = safeReadText(root, file);
-    try {
-        const parsed = JSON.parse(raw ?? "");
-        if (isObject(parsed))
-            return parsed;
-    }
-    catch (err) {
-        return fail("autopilot_metrics_input_invalid", `Report input is not valid JSON: ${err instanceof Error ? err.message : String(err)}`, { path: file });
-    }
-    return fail("autopilot_metrics_input_invalid", "Report input must be a JSON object", { path: file });
-}
-function isCurrentHostLabel(label, host) {
-    return label === "local" ? host.outpostId === null : label === host.outpostId || label === host.hostname;
-}
-function loadJuniors(root, host) {
-    const file = path.join(root, JUNIORS_REL);
-    const parsed = parseJsonObject(root, file);
-    if (!Array.isArray(parsed.juniors))
-        return fail("autopilot_metrics_input_invalid", "Team registry must contain a juniors array", { path: file });
-    const seen = new Set();
-    return parsed.juniors.flatMap((value, index) => {
-        if (!isObject(value) || typeof value.host !== "string" || !value.host.trim()) {
-            return fail("autopilot_metrics_input_invalid", "Team registry row must identify its host", { path: file, index });
-        }
-        if (!isCurrentHostLabel(value.host, host))
-            return [];
-        if (["team", "lane", "status", "prd"].some((field) => typeof value[field] !== "string" || !value[field].trim())) {
-            return fail("autopilot_metrics_input_invalid", "Selected team registry row must contain team, lane, status, and prd strings", { path: file, index });
-        }
-        const entry = value;
-        if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(entry.team) || entry.lane.includes("/") || entry.lane.includes("\\")) {
-            return fail("autopilot_metrics_input_invalid", "Team registry row contains an unsafe team or lane id", { path: file, index });
-        }
-        if (seen.has(entry.lane))
-            return fail("autopilot_metrics_mapping_ambiguous", "A lead lane appears more than once in the selected host registry", { path: file, lane_id: entry.lane });
-        seen.add(entry.lane);
-        return [entry];
-    });
-}
-function projectPath(root, raw, registryPath) {
-    if (path.isAbsolute(raw))
-        return fail("autopilot_metrics_mapping_invalid", "Project path must be relative to the HQ root", { path: registryPath, project_path: raw });
-    const absolute = path.resolve(root, raw);
-    if (!absolute.startsWith(`${path.resolve(root)}${path.sep}`)) {
-        return fail("autopilot_metrics_mapping_invalid", "Project path must stay under the HQ root", { path: registryPath, project_path: raw });
-    }
-    return absolute;
-}
-function loadProject(root, projectId, rawPrd) {
-    const registryPath = path.join(root, JUNIORS_REL);
-    const file = projectPath(root, rawPrd, registryPath);
-    const parsed = parseJsonObject(root, file);
-    const storiesValue = parsed.userStories === undefined ? parsed.stories : parsed.userStories;
-    if (!Array.isArray(storiesValue))
-        return fail("autopilot_metrics_input_invalid", "Project must contain a userStories or stories array", { path: file });
-    const stories = storiesValue.map((value, index) => {
-        if (!isObject(value) || typeof value.id !== "string" || !value.id.trim()) {
-            return fail("autopilot_metrics_input_invalid", "Project story must have a non-empty id", { path: file, index });
-        }
-        return value;
-    });
-    return { project_id: projectId, stories };
-}
-function parseIso(value, field, file) {
-    const normalized = normalizeIsoTimestamp(value);
-    if (normalized !== null)
-        return normalized;
-    if (typeof value === "string") {
-        const minutePrecision = /^(\d{4}-\d\d-\d\dT\d\d:\d\d)(Z|[+-]\d\d:\d\d)$/.exec(value);
-        if (minutePrecision) {
-            const withSeconds = normalizeIsoTimestamp(`${minutePrecision[1]}:00${minutePrecision[2]}`);
-            if (withSeconds !== null)
-                return withSeconds;
-        }
-    }
-    return fail("autopilot_metrics_input_invalid", `${field} must be an ISO timestamp`, { path: file, field });
-}
-function readJsonl(root, file, missingOk = false) {
-    const text = safeReadText(root, file, missingOk);
-    if (text === null)
-        return [];
-    const records = [];
-    for (const [index, line] of text.split("\n").entries()) {
-        if (!line.trim())
-            continue;
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch (err) {
-            return fail("autopilot_metrics_input_invalid", `Report JSONL contains malformed JSON: ${err instanceof Error ? err.message : String(err)}`, { path: file, line: index + 1 });
-        }
-        if (!isObject(parsed))
-            return fail("autopilot_metrics_input_invalid", "Report JSONL rows must be objects", { path: file, line: index + 1 });
-        records.push(parsed);
-    }
-    return records;
-}
-function listRegularFiles(root, directory, output, depth = 0) {
-    let names;
-    try {
-        const stat = fs.lstatSync(directory);
-        if (stat.isSymbolicLink() || !stat.isDirectory())
-            return fail("autopilot_metrics_input_invalid", "Report path must be a regular directory", { path: directory });
-        const realRoot = fs.realpathSync(root);
-        const realDirectory = fs.realpathSync(directory);
-        if (!realDirectory.startsWith(`${realRoot}${path.sep}`))
-            return fail("autopilot_metrics_input_invalid", "Report directory must stay under the HQ root", { path: directory });
-        names = fs.readdirSync(directory);
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return;
-        if (err instanceof LanesError)
-            throw err;
-        return fail("autopilot_metrics_input_unreadable", `Could not list report directory: ${err instanceof Error ? err.message : String(err)}`, { path: directory });
-    }
-    for (const name of names) {
-        if (!name || name.startsWith("."))
-            continue;
-        const candidate = path.join(directory, name);
-        let stat;
-        try {
-            stat = fs.lstatSync(candidate);
-        }
-        catch (err) {
-            return fail("autopilot_metrics_input_unreadable", `Could not inspect report file: ${err instanceof Error ? err.message : String(err)}`, { path: candidate });
-        }
-        if (stat.isSymbolicLink())
-            return fail("autopilot_metrics_input_invalid", "Report directory may not contain symbolic links", { path: candidate });
-        if (stat.isFile() && name.endsWith(".jsonl"))
-            output.push(candidate);
-        else if (stat.isDirectory() && depth < 2)
-            listRegularFiles(root, candidate, output, depth + 1);
-    }
-}
-function readLeadMessages(root, laneId) {
-    const dropbox = path.join(root, LANES_RUNS_REL, laneId, DROPBOX_NAME);
-    const allFiles = [];
-    for (const name of ["draining", "inflight", "delivered", "undeliverable"])
-        listRegularFiles(root, path.join(dropbox, name), allFiles);
-    const inbox = path.join(dropbox, "inbox.jsonl");
-    try {
-        const stat = fs.lstatSync(inbox);
-        if (stat.isSymbolicLink() || !stat.isFile())
-            return fail("autopilot_metrics_input_invalid", "Lead inbox must be a regular file", { path: inbox });
-        allFiles.push(inbox);
-    }
-    catch (err) {
-        if (err.code !== "ENOENT")
-            throw err;
-    }
-    const seen = new Set();
-    const nudges = [];
-    const resumes = [];
-    for (const file of new Set(allFiles)) {
-        const resumeFile = file.endsWith(RESUME_SUFFIX);
-        for (const row of readJsonl(root, file)) {
-            // Undated records cannot be assigned to a report day, regardless of their file.
-            if (typeof row.at !== "string")
-                continue;
-            const at = parseIso(row.at, "at", file);
-            const text = typeof row.text === "string" ? row.text : "";
-            const messageId = typeof row.message_id === "string" ? row.message_id : `${at}\u0000${text}`;
-            if (!seen.has(messageId)) {
-                seen.add(messageId);
-                if (resumeFile || row.kind !== "monitor_event")
-                    nudges.push({ team: "", at });
-            }
-            if (resumeFile)
-                resumes.push({ lane_id: laneId, at });
-        }
-    }
-    return { nudges, resumes };
-}
-function loadNudgeDefects(root, selectedTeams) {
-    const file = path.join(root, OPERATOR_NUDGE_DEFECTS_REL);
-    return readJsonl(root, file, true).flatMap((row, index) => {
-        if (typeof row.team === "string" && !selectedTeams.has(row.team))
-            return [];
-        const defect = typeof row.defect === "string" && row.defect.trim() ? row.defect : row.why;
-        if (typeof row.team !== "string" || !row.team.trim() || typeof defect !== "string" || !defect.trim()) {
-            return fail("autopilot_metrics_input_invalid", "Nudge-defect row must contain at, team, and defect (or legacy why)", { path: file, line: index + 1 });
-        }
-        return [{ at: parseIso(row.at, "at", file), team: row.team, defect }];
-    });
-}
-function loadReviews(root) {
-    const listing = listLaneReviews(root);
-    if (listing.skipped > 0)
-        return fail("autopilot_metrics_review_record_invalid", "One or more lane review records could not be read", { skipped: listing.skipped });
-    return listing.reviews.flatMap((review) => review.history.map((entry) => ({
-        repo: entry.repo,
-        pr: entry.pr,
-        recorded_at: entry.recorded_at,
-        worker_lane: entry.worker_lane,
-    })));
-}
-function selectLeads(root, host) {
-    const juniors = loadJuniors(root, host);
-    const lanes = readAllLanes(root);
-    const leads = [];
-    const projects = [];
-    const laneIds = new Set();
-    const projectIds = new Set();
-    for (const entry of juniors) {
-        const matchingLanes = lanes.filter((candidate) => candidate.lane_id === entry.lane || candidate.lane_id.startsWith(`${entry.lane}_`));
-        const lane = matchingLanes.find((candidate) => laneRunsHere(candidate, host));
-        if (!lane) {
-            return fail("autopilot_metrics_lead_missing", "Registered lead lane could not be read on this host", { team: entry.team, lane_id: entry.lane });
-        }
-        if (laneIds.has(lane.lane_id))
-            return fail("autopilot_metrics_mapping_ambiguous", "A lead lane appears more than once in the host report", { lane_id: lane.lane_id });
-        const projectKey = JSON.stringify([lane.project_id, projectPath(root, entry.prd, path.join(root, JUNIORS_REL))]);
-        const lead = { team: entry.team, lane_id: lane.lane_id, project_id: projectKey };
-        leads.push(lead);
-        laneIds.add(lane.lane_id);
-        if (!projectIds.has(projectKey)) {
-            projects.push(loadProject(root, projectKey, entry.prd));
-            projectIds.add(projectKey);
-        }
-    }
-    return { leads, projects, laneIds };
-}
-function windowFromOptions(now, options) {
-    const until = normalizeIsoTimestamp(now.toISOString());
-    if (until === null)
-        return fail("autopilot_metrics_window_invalid", "Current time is invalid");
-    if (options.since !== undefined && options.days !== undefined)
-        return fail("autopilot_metrics_window_invalid", "Use either --since or --days, not both");
-    if (options.since !== undefined) {
-        const since = normalizeIsoTimestamp(options.since);
-        if (since === null || Date.parse(since) >= Date.parse(until))
-            return fail("autopilot_metrics_window_invalid", "--since must be an ISO timestamp before now", { since: options.since });
-        return { since, until };
-    }
-    const days = options.days === undefined ? 3 : Number(options.days);
-    if (!Number.isSafeInteger(days) || days < 1 || days > 366)
-        return fail("autopilot_metrics_window_invalid", "--days must be an integer from 1 to 366", { days: options.days });
-    return { since: new Date(Date.parse(until) - days * 24 * 60 * 60 * 1000).toISOString(), until };
-}
-function printJson(value) {
-    console.log(JSON.stringify(value));
-}
-export function registerLaneAutopilotReportCommand(parent, deps, wrap) {
-    const autopilot = parent.command("autopilot").description("Measure automated lead-lane follow-through");
-    autopilot.command("report")
-        .description("Report operator nudges, review latency, and idle slots with ready work")
-        .option("--since <iso>", "Include activity since this ISO timestamp")
-        .option("--days <n>", "Include the most recent number of days")
-        .option("--json", "Print JSON")
-        .action(wrap(async (options) => {
-        const root = deps.hqRoot();
-        const window = windowFromOptions(deps.now(), options);
-        const host = deps.currentHost();
-        const selected = selectLeads(root, host);
-        const lanes = readAllLanes(root);
-        const nudges = [];
-        const resumes = [];
-        for (const lead of selected.leads) {
-            const events = readLeadMessages(root, lead.lane_id);
-            nudges.push(...events.nudges.map((event) => ({ ...event, team: lead.team })));
-            resumes.push(...events.resumes);
-            const record = lanes.find((lane) => lane.lane_id === lead.lane_id);
-            const lastResume = record?.last_resume?.at;
-            if (lastResume && !resumes.some((resume) => resume.lane_id === lead.lane_id && resume.at === lastResume))
-                resumes.push({ lane_id: lead.lane_id, at: lastResume });
-        }
-        const reviewListing = loadReviews(root);
-        const defects = loadNudgeDefects(root, new Set(selected.leads.map((lead) => lead.team)));
-        const result = buildAutopilotMetricsReport({
-            ...window,
-            leads: selected.leads,
-            lanes: lanes,
-            projects: selected.projects,
-            reviews: reviewListing,
-            nudges,
-            nudgeDefects: defects,
-            seniorResumes: resumes,
-        });
-        printJson(result);
-    }));
-}
-//# sourceMappingURL=lanes-autopilot.js.map

package/dist/commands/lanes-checks.d.ts

@@ -1,51 +0,0 @@
-import type { Command } from "commander";
-import { type TrackerCheckTeam } from "../lib/lanes/tracker-checks.js";
-import { type TrackerKind, type TrackerRecord } from "../lib/lanes/tracker-store.js";
-import type { LaneRecord, LaneCompanyRef, QuestionRecord } from "../lib/lanes/types.js";
-export interface LaneChecksDeps {
-    hqRoot: () => string;
-    resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
-    now: () => Date;
-    stopLane?: (laneId: string, reason: string) => Promise<void>;
-    sessionState?: (root: string, sessionId: string, now: Date) => string | null;
-}
-type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
-export interface ProjectMapping {
-    projectId: string;
-    team: string;
-    leadLaneId?: string;
-    statusPath: string;
-    storyPrefix?: string;
-    excludePrefix?: string;
-}
-export declare function mappingIncludesStory(mapping: ProjectMapping, storyId: string): boolean;
-export interface ProjectReadResult {
-    stories: Array<Record<string, unknown>>;
-    mtime: number;
-    errors?: Array<{
-        path: string;
-        field: string;
-        message: string;
-        story_id?: string;
-    }>;
-}
-export declare function loadProjectMappings(root: string, company: string, requestedProject?: string): Map<string, ProjectMapping>;
-export declare function readProject(root: string, company: string, prdPath: string, tolerantStories?: boolean): ProjectReadResult;
-export declare function loadCompanyQuestionRecords(root: string, company: LaneCompanyRef, projectId?: string): QuestionRecord[];
-export declare function readTeamInputs(root: string, company: LaneCompanyRef, projects: readonly ProjectMapping[], lanes: readonly LaneRecord[]): TrackerCheckTeam[];
-export declare function pathForTrackerRecord(projectDirectory: string, kind: TrackerKind, id: string): string;
-export interface TolerantTrackerReadIssue {
-    path: string;
-    field: string;
-    message: string;
-    record_id?: string;
-}
-/** Report loader that preserves valid records while making every unreadable file visible. */
-export declare function listTrackerRecordsTolerant(projectDirectory: string, kind: TrackerKind): {
-    records: TrackerRecord[];
-    errors: TolerantTrackerReadIssue[];
-};
-export declare function resolveTrackerCompany(deps: LaneChecksDeps, requested?: string): Promise<LaneCompanyRef>;
-export declare function registerLaneChecksCommand(parent: Command, deps: LaneChecksDeps, wrap: WrapHandler): void;
-export {};
-//# sourceMappingURL=lanes-checks.d.ts.map