@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.2

package/dist/repertoire/ado-templates.js

@@ -0,0 +1,146 @@
+"use strict";
+// Process template awareness -- fetches process template definitions from ADO,
+// derives hierarchy rules, and validates parent/child work item type relationships.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchProcessTemplate = fetchProcessTemplate;
+exports.deriveHierarchyRules = deriveHierarchyRules;
+exports.validateParentChild = validateParentChild;
+const ado_client_1 = require("./ado-client");
+const runtime_1 = require("../nerves/runtime");
+// Known hierarchy definitions for common ADO process templates.
+// Maps template name to explicit parent -> allowed children mappings.
+// Bug appears at multiple levels in Agile/Scrum (can be child of Feature, User Story, or PBI).
+const KNOWN_HIERARCHIES = {
+    "Basic": {
+        "Epic": ["Issue"],
+        "Issue": ["Task"],
+        "Task": [],
+    },
+    "Agile": {
+        "Epic": ["Feature"],
+        "Feature": ["User Story", "Bug"],
+        "User Story": ["Task", "Bug"],
+        "Task": [],
+        "Bug": ["Task"],
+    },
+    "Scrum": {
+        "Epic": ["Feature"],
+        "Feature": ["Product Backlog Item", "Bug"],
+        "Product Backlog Item": ["Task", "Bug"],
+        "Task": [],
+        "Bug": ["Task"],
+    },
+    "CMMI": {
+        "Epic": ["Feature"],
+        "Feature": ["Requirement", "Bug"],
+        "Requirement": ["Task", "Bug"],
+        "Task": [],
+        "Bug": ["Task"],
+    },
+};
+/**
+ * Fetch the process template for an ADO project.
+ * Returns null if fetching fails (tools proceed without validation).
+ */
+async function fetchProcessTemplate(token, organization, project) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.ado_template_fetch",
+        message: "fetching process template",
+        meta: {},
+    });
+    try {
+        // Step 1: Get the process template type from project properties
+        const propsResult = await (0, ado_client_1.adoRequest)(token, "GET", organization, `/${project}/_apis/properties`);
+        let propsData;
+        try {
+            propsData = JSON.parse(propsResult);
+        }
+        catch {
+            return null;
+        }
+        const templateProp = propsData.value?.find(p => p.name === "System.ProcessTemplateType");
+        if (!templateProp)
+            return null;
+        // Step 2: Fetch process template details
+        const templateResult = await (0, ado_client_1.adoRequest)(token, "GET", organization, `/_apis/work/processes/${templateProp.value}`);
+        let templateData;
+        try {
+            templateData = JSON.parse(templateResult);
+        }
+        catch {
+            return null;
+        }
+        if (!templateData.name)
+            return null;
+        // Step 3: Fetch work item types for the project
+        const typesResult = await (0, ado_client_1.adoRequest)(token, "GET", organization, `/${project}/_apis/wit/workitemtypes`);
+        let typesData;
+        try {
+            typesData = JSON.parse(typesResult);
+        }
+        catch {
+            return null;
+        }
+        if (!typesData.value)
+            return null;
+        return {
+            templateName: templateData.name,
+            templateId: templateProp.value,
+            workItemTypes: typesData.value.map(t => t.name),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Derive hierarchy rules from a process template name and available work item types.
+ * Returns a map of parent type -> allowed child types.
+ *
+ * For known templates (Basic, Agile, Scrum, CMMI), uses predefined hierarchies.
+ * For unknown templates, returns empty child arrays (no validation possible).
+ */
+function deriveHierarchyRules(templateName, workItemTypes) {
+    const rules = {};
+    // Initialize all types with empty children
+    for (const type of workItemTypes) {
+        rules[type] = [];
+    }
+    const hierarchy = KNOWN_HIERARCHIES[templateName];
+    if (!hierarchy)
+        return rules;
+    // Apply known hierarchy rules, filtering to types actually present in the project
+    const typeSet = new Set(workItemTypes);
+    for (const [parentType, children] of Object.entries(hierarchy)) {
+        if (typeSet.has(parentType)) {
+            rules[parentType] = children.filter(t => typeSet.has(t));
+        }
+    }
+    return rules;
+}
+/**
+ * Validate whether a child work item type can be parented under a given parent type.
+ */
+function validateParentChild(rules, parentType, childType) {
+    const allowedChildren = rules[parentType];
+    if (allowedChildren === undefined) {
+        return {
+            valid: false,
+            violations: [`Unknown parent type: ${parentType}. Not found in project's work item types.`],
+        };
+    }
+    if (allowedChildren.length === 0) {
+        return {
+            valid: false,
+            violations: [`${parentType} cannot have children (leaf type). ${childType} cannot be a child of ${parentType}.`],
+        };
+    }
+    if (!allowedChildren.includes(childType)) {
+        return {
+            valid: false,
+            violations: [`${childType} cannot be a child of ${parentType}. Allowed children: ${allowedChildren.join(", ")}.`],
+        };
+    }
+    return { valid: true, violations: [] };
+}

package/dist/repertoire/coding/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCodingMonitorReport = exports.CodingSessionMonitor = exports.CodingSessionManager = void 0;
+exports.getCodingSessionManager = getCodingSessionManager;
+exports.resetCodingSessionManager = resetCodingSessionManager;
+const runtime_1 = require("../../nerves/runtime");
+const manager_1 = require("./manager");
+let manager = null;
+function getCodingSessionManager() {
+    if (!manager) {
+        manager = new manager_1.CodingSessionManager({});
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.coding_manager_init",
+            message: "initialized coding session manager singleton",
+            meta: {},
+        });
+    }
+    return manager;
+}
+function resetCodingSessionManager() {
+    manager?.shutdown();
+    manager = null;
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.coding_manager_reset",
+        message: "reset coding session manager singleton",
+        meta: {},
+    });
+}
+var manager_2 = require("./manager");
+Object.defineProperty(exports, "CodingSessionManager", { enumerable: true, get: function () { return manager_2.CodingSessionManager; } });
+var monitor_1 = require("./monitor");
+Object.defineProperty(exports, "CodingSessionMonitor", { enumerable: true, get: function () { return monitor_1.CodingSessionMonitor; } });
+var reporter_1 = require("./reporter");
+Object.defineProperty(exports, "formatCodingMonitorReport", { enumerable: true, get: function () { return reporter_1.formatCodingMonitorReport; } });

package/dist/repertoire/coding/manager.js

@@ -0,0 +1,489 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodingSessionManager = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
+const spawner_1 = require("./spawner");
+function safeAgentName() {
+    try {
+        return (0, identity_1.getAgentName)();
+    }
+    catch {
+        return "default";
+    }
+}
+function defaultStateFilePath(agentName) {
+    return path.join(os.homedir(), ".agentstate", agentName, "coding", "sessions.json");
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function cloneSession(session) {
+    return {
+        ...session,
+        failure: session.failure
+            ? {
+                ...session.failure,
+                args: [...session.failure.args],
+            }
+            : null,
+    };
+}
+function extractSequence(id) {
+    const match = /^coding-(\d+)$/.exec(id);
+    if (!match)
+        return 0;
+    return Number.parseInt(match[1], 10);
+}
+function isActiveSessionStatus(status) {
+    return status === "spawning" || status === "running" || status === "waiting_input" || status === "stalled";
+}
+function appendTail(existing, nextChunk, maxLength = 2000) {
+    const combined = `${existing}${nextChunk}`;
+    return combined.length <= maxLength ? combined : combined.slice(combined.length - maxLength);
+}
+function isSpawnCodingResult(value) {
+    return typeof value === "object" && value !== null && "process" in value;
+}
+function normalizeSpawnResult(result) {
+    if (isSpawnCodingResult(result)) {
+        return {
+            process: result.process,
+            command: result.command,
+            args: [...result.args],
+            prompt: result.prompt,
+        };
+    }
+    return {
+        process: result,
+        command: "unknown",
+        args: [],
+        prompt: "",
+    };
+}
+function defaultFailureDiagnostics(code, signal, command, args, stdoutTail, stderrTail) {
+    return {
+        command,
+        args: [...args],
+        code,
+        signal,
+        stdoutTail: stdoutTail.trim(),
+        stderrTail: stderrTail.trim(),
+    };
+}
+class CodingSessionManager {
+    records = new Map();
+    spawnProcess;
+    nowIso;
+    maxRestarts;
+    defaultStallThresholdMs;
+    stateFilePath;
+    existsSync;
+    readFileSync;
+    writeFileSync;
+    mkdirSync;
+    pidAlive;
+    agentName;
+    sequence = 0;
+    constructor(options) {
+        this.spawnProcess = options.spawnProcess ?? ((request) => (0, spawner_1.spawnCodingProcess)(request));
+        this.nowIso = options.nowIso ?? (() => new Date().toISOString());
+        this.maxRestarts = options.maxRestarts ?? 1;
+        this.defaultStallThresholdMs = options.defaultStallThresholdMs ?? 5 * 60_000;
+        this.existsSync = options.existsSync ?? fs.existsSync;
+        this.readFileSync = options.readFileSync ?? fs.readFileSync;
+        this.writeFileSync = options.writeFileSync ?? fs.writeFileSync;
+        this.mkdirSync = options.mkdirSync ?? fs.mkdirSync;
+        this.pidAlive = options.pidAlive ?? isPidAlive;
+        this.agentName = options.agentName ?? safeAgentName();
+        this.stateFilePath = options.stateFilePath ?? defaultStateFilePath(this.agentName);
+        this.loadPersistedState();
+    }
+    async spawnSession(request) {
+        this.sequence += 1;
+        const id = `coding-${String(this.sequence).padStart(3, "0")}`;
+        const now = this.nowIso();
+        const normalizedRequest = {
+            ...request,
+            sessionId: id,
+            parentAgent: request.parentAgent ?? this.agentName,
+        };
+        const session = {
+            id,
+            runner: normalizedRequest.runner,
+            workdir: normalizedRequest.workdir,
+            taskRef: normalizedRequest.taskRef,
+            scopeFile: normalizedRequest.scopeFile,
+            stateFile: normalizedRequest.stateFile,
+            status: "spawning",
+            pid: null,
+            startedAt: now,
+            lastActivityAt: now,
+            endedAt: null,
+            restartCount: 0,
+            lastExitCode: null,
+            lastSignal: null,
+            failure: null,
+        };
+        const spawned = normalizeSpawnResult(this.spawnProcess(normalizedRequest));
+        session.pid = spawned.process.pid ?? null;
+        session.status = "running";
+        const record = {
+            request: normalizedRequest,
+            session,
+            process: spawned.process,
+            command: spawned.command,
+            args: [...spawned.args],
+            stdoutTail: "",
+            stderrTail: "",
+        };
+        this.records.set(id, record);
+        this.attachProcessListeners(record);
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.coding_session_spawned",
+            message: "coding session spawned",
+            meta: { id, runner: normalizedRequest.runner, pid: session.pid },
+        });
+        this.persistState();
+        return cloneSession(session);
+    }
+    listSessions() {
+        return [...this.records.values()]
+            .map((record) => cloneSession(record.session))
+            .sort((a, b) => a.id.localeCompare(b.id));
+    }
+    getSession(sessionId) {
+        const record = this.records.get(sessionId);
+        return record ? cloneSession(record.session) : null;
+    }
+    sendInput(sessionId, input) {
+        const record = this.records.get(sessionId);
+        if (!record || !record.process) {
+            return { ok: false, message: `session not found: ${sessionId}` };
+        }
+        record.process.stdin.write(`${input}\n`);
+        record.session.lastActivityAt = this.nowIso();
+        if (record.session.status === "waiting_input" || record.session.status === "stalled") {
+            record.session.status = "running";
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.coding_session_input",
+            message: "forwarded input to coding session",
+            meta: { id: sessionId },
+        });
+        this.persistState();
+        return { ok: true, message: `input sent to ${sessionId}` };
+    }
+    killSession(sessionId) {
+        const record = this.records.get(sessionId);
+        if (!record || !record.process) {
+            return { ok: false, message: `session not found: ${sessionId}` };
+        }
+        record.process.kill("SIGTERM");
+        record.process = null;
+        record.session.status = "killed";
+        record.session.endedAt = this.nowIso();
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.coding_session_killed",
+            message: "coding session terminated",
+            meta: { id: sessionId },
+        });
+        this.persistState();
+        return { ok: true, message: `killed ${sessionId}` };
+    }
+    checkStalls(nowMs = Date.now()) {
+        let stalled = 0;
+        for (const record of this.records.values()) {
+            if (record.session.status !== "running")
+                continue;
+            const threshold = record.request.stallThresholdMs ?? this.defaultStallThresholdMs;
+            const elapsed = nowMs - Date.parse(record.session.lastActivityAt);
+            if (elapsed <= threshold)
+                continue;
+            stalled += 1;
+            record.session.status = "stalled";
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "repertoire",
+                event: "repertoire.coding_session_stalled",
+                message: "coding session stalled",
+                meta: { id: record.session.id, elapsedMs: elapsed },
+            });
+            if (record.request.autoRestartOnStall !== false && record.session.restartCount < this.maxRestarts) {
+                this.restartSession(record, "stalled");
+            }
+        }
+        if (stalled > 0) {
+            this.persistState();
+        }
+        return stalled;
+    }
+    shutdown() {
+        for (const record of this.records.values()) {
+            if (!record.process)
+                continue;
+            record.process.kill("SIGTERM");
+            record.process = null;
+            if (record.session.status === "running" || record.session.status === "spawning") {
+                record.session.status = "killed";
+                record.session.endedAt = this.nowIso();
+            }
+        }
+        this.persistState();
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.coding_manager_shutdown",
+            message: "coding session manager shutdown complete",
+            meta: { sessionCount: this.records.size },
+        });
+    }
+    attachProcessListeners(record) {
+        if (!record.process)
+            return;
+        record.process.stdout.on("data", (chunk) => {
+            this.onOutput(record, chunk.toString(), "stdout");
+        });
+        record.process.stderr.on("data", (chunk) => {
+            this.onOutput(record, chunk.toString(), "stderr");
+        });
+        record.process.on("exit", (code, signal) => {
+            this.onExit(record, code, signal);
+        });
+    }
+    onOutput(record, text, stream) {
+        record.session.lastActivityAt = this.nowIso();
+        if (stream === "stdout") {
+            record.stdoutTail = appendTail(record.stdoutTail, text);
+        }
+        else {
+            record.stderrTail = appendTail(record.stderrTail, text);
+        }
+        if (text.includes("status: NEEDS_REVIEW") || text.includes("❌ blocked")) {
+            record.session.status = "waiting_input";
+        }
+        if (text.includes("✅ all units complete")) {
+            record.session.status = "completed";
+            record.session.endedAt = this.nowIso();
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.coding_session_output",
+            message: "received coding session output",
+            meta: { id: record.session.id, status: record.session.status },
+        });
+        this.persistState();
+    }
+    onExit(record, code, signal) {
+        if (!record.process)
+            return;
+        record.process = null;
+        record.session.pid = null;
+        record.session.lastExitCode = code;
+        record.session.lastSignal = signal;
+        if (record.session.status === "killed" || record.session.status === "completed") {
+            record.session.endedAt = this.nowIso();
+            this.persistState();
+            return;
+        }
+        if (code === 0) {
+            record.session.status = "completed";
+            record.session.endedAt = this.nowIso();
+            this.persistState();
+            return;
+        }
+        if (record.request.autoRestartOnCrash !== false && record.session.restartCount < this.maxRestarts) {
+            this.restartSession(record, "crash");
+            return;
+        }
+        record.session.status = "failed";
+        record.session.endedAt = this.nowIso();
+        record.session.failure = defaultFailureDiagnostics(code, signal, record.command, record.args, record.stdoutTail, record.stderrTail);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "repertoire",
+            event: "repertoire.coding_session_failed",
+            message: "coding session failed without restart",
+            meta: { id: record.session.id, code, signal, command: record.command },
+        });
+        this.persistState();
+    }
+    restartSession(record, reason) {
+        const replacement = normalizeSpawnResult(this.spawnProcess(record.request));
+        record.process = replacement.process;
+        record.command = replacement.command;
+        record.args = [...replacement.args];
+        record.stdoutTail = "";
+        record.stderrTail = "";
+        record.session.pid = replacement.process.pid ?? null;
+        record.session.restartCount += 1;
+        record.session.status = "running";
+        record.session.lastActivityAt = this.nowIso();
+        record.session.endedAt = null;
+        record.session.failure = null;
+        this.attachProcessListeners(record);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "repertoire",
+            event: "repertoire.coding_session_restarted",
+            message: "coding session restarted",
+            meta: { id: record.session.id, reason, restartCount: record.session.restartCount },
+        });
+        this.persistState();
+    }
+    loadPersistedState() {
+        if (!this.existsSync(this.stateFilePath)) {
+            return;
+        }
+        let raw;
+        try {
+            raw = this.readFileSync(this.stateFilePath, "utf-8");
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "repertoire",
+                event: "repertoire.coding_state_load_error",
+                message: "failed reading coding session state",
+                meta: { path: this.stateFilePath, reason: error instanceof Error ? error.message : String(error) },
+            });
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "repertoire",
+                event: "repertoire.coding_state_load_error",
+                message: "invalid coding session state JSON",
+                meta: { path: this.stateFilePath, reason: error instanceof Error ? error.message : String(error) },
+            });
+            return;
+        }
+        if (!Array.isArray(parsed.records)) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "repertoire",
+                event: "repertoire.coding_state_load_error",
+                message: "coding session state missing records array",
+                meta: { path: this.stateFilePath },
+            });
+            return;
+        }
+        this.sequence = Number.isInteger(parsed.sequence) && parsed.sequence >= 0 ? parsed.sequence : 0;
+        for (const item of parsed.records) {
+            const request = item?.request;
+            const session = item?.session;
+            if (!request || !session || typeof session.id !== "string") {
+                continue;
+            }
+            const normalizedRequest = {
+                ...request,
+                sessionId: request.sessionId ?? session.id,
+                parentAgent: request.parentAgent ?? this.agentName,
+            };
+            const normalizedSession = {
+                ...session,
+                taskRef: session.taskRef ?? normalizedRequest.taskRef,
+                failure: session.failure ?? null,
+            };
+            if (typeof normalizedSession.pid === "number") {
+                const alive = this.pidAlive(normalizedSession.pid);
+                if (!alive && isActiveSessionStatus(normalizedSession.status)) {
+                    normalizedSession.status = "failed";
+                    normalizedSession.endedAt = normalizedSession.endedAt ?? this.nowIso();
+                    normalizedSession.failure =
+                        normalizedSession.failure ??
+                            defaultFailureDiagnostics(normalizedSession.lastExitCode, normalizedSession.lastSignal, "restored", [], "", "process not running during manager restore");
+                    normalizedSession.pid = null;
+                }
+            }
+            this.records.set(normalizedSession.id, {
+                request: normalizedRequest,
+                session: normalizedSession,
+                process: null,
+                command: normalizedSession.failure?.command ?? "restored",
+                args: normalizedSession.failure ? [...normalizedSession.failure.args] : [],
+                stdoutTail: normalizedSession.failure?.stdoutTail ?? "",
+                stderrTail: normalizedSession.failure?.stderrTail ?? "",
+            });
+            this.sequence = Math.max(this.sequence, extractSequence(normalizedSession.id));
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.coding_state_loaded",
+            message: "loaded persisted coding sessions",
+            meta: { count: this.records.size },
+        });
+    }
+    persistState() {
+        const payload = {
+            sequence: this.sequence,
+            records: [...this.records.values()].map((record) => ({
+                request: record.request,
+                session: record.session,
+            })),
+        };
+        try {
+            this.mkdirSync(path.dirname(this.stateFilePath), { recursive: true });
+            this.writeFileSync(this.stateFilePath, JSON.stringify(payload, null, 2) + "\n", "utf-8");
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "repertoire",
+                event: "repertoire.coding_state_persist_error",
+                message: "failed persisting coding sessions",
+                meta: { path: this.stateFilePath, reason: error instanceof Error ? error.message : String(error) },
+            });
+        }
+    }
+}
+exports.CodingSessionManager = CodingSessionManager;