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

package/dist/repertoire/coding/monitor.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodingSessionMonitor = void 0;
+const runtime_1 = require("../../nerves/runtime");
+class CodingSessionMonitor {
+    manager;
+    nowMs;
+    constructor(options) {
+        this.manager = options.manager;
+        this.nowMs = options.nowMs ?? Date.now;
+    }
+    tick() {
+        const now = this.nowMs();
+        const detectedStalls = this.manager.checkStalls(now);
+        const sessions = this.manager.listSessions();
+        const blockedSessionIds = sessions.filter((session) => session.status === "waiting_input").map((session) => session.id);
+        const stalledSessionIds = sessions.filter((session) => session.status === "stalled").map((session) => session.id);
+        const completedSessionIds = sessions.filter((session) => session.status === "completed").map((session) => session.id);
+        const failedSessionIds = sessions.filter((session) => session.status === "failed").map((session) => session.id);
+        const restarts = sessions.reduce((sum, session) => sum + session.restartCount, 0);
+        const recoveryActions = [];
+        for (const sessionId of blockedSessionIds) {
+            recoveryActions.push({ sessionId, action: "send_guidance", reason: "waiting_input" });
+        }
+        for (const sessionId of stalledSessionIds) {
+            recoveryActions.push({ sessionId, action: "send_guidance", reason: "stalled" });
+        }
+        for (const sessionId of failedSessionIds) {
+            recoveryActions.push({ sessionId, action: "manual_intervention_required", reason: "failed" });
+        }
+        const report = {
+            at: new Date(now).toISOString(),
+            summary: {
+                active: sessions.length,
+                completed: completedSessionIds.length,
+                blocked: blockedSessionIds.length,
+                stalled: Math.max(stalledSessionIds.length, detectedStalls),
+                failed: failedSessionIds.length,
+                restarts,
+            },
+            blockedSessionIds,
+            stalledSessionIds,
+            completedSessionIds,
+            recoveryActions,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.coding_monitor_tick",
+            message: "coding monitor tick completed",
+            meta: {
+                active: report.summary.active,
+                blocked: report.summary.blocked,
+                stalled: report.summary.stalled,
+                failed: report.summary.failed,
+            },
+        });
+        return report;
+    }
+}
+exports.CodingSessionMonitor = CodingSessionMonitor;

package/dist/repertoire/coding/reporter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCodingMonitorReport = formatCodingMonitorReport;
+const runtime_1 = require("../../nerves/runtime");
+function formatCodingMonitorReport(report) {
+    const lines = [];
+    lines.push(`coding-monitor at=${report.at}`);
+    lines.push([
+        `active=${report.summary.active}`,
+        `completed=${report.summary.completed}`,
+        `blocked=${report.summary.blocked}`,
+        `stalled=${report.summary.stalled}`,
+        `failed=${report.summary.failed}`,
+        `restarts=${report.summary.restarts}`,
+    ].join(" "));
+    if (report.summary.active === 0) {
+        lines.push("no active coding sessions");
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.coding_monitor_report",
+            message: "formatted coding monitor report",
+            meta: { active: report.summary.active, lineCount: lines.length },
+        });
+        return lines.join("\n");
+    }
+    if (report.blockedSessionIds.length > 0) {
+        lines.push(`blocked: ${report.blockedSessionIds.join(",")}`);
+    }
+    if (report.stalledSessionIds.length > 0) {
+        lines.push(`stalled: ${report.stalledSessionIds.join(",")}`);
+    }
+    if (report.completedSessionIds.length > 0) {
+        lines.push(`completed: ${report.completedSessionIds.join(",")}`);
+    }
+    for (const action of report.recoveryActions) {
+        lines.push(`recovery: ${action.sessionId} -> ${action.action} (${action.reason})`);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.coding_monitor_report",
+        message: "formatted coding monitor report",
+        meta: { active: report.summary.active, lineCount: lines.length },
+    });
+    return lines.join("\n");
+}

package/dist/repertoire/coding/spawner.js

@@ -0,0 +1,102 @@
+"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.spawnCodingProcess = spawnCodingProcess;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../../nerves/runtime");
+function buildCommandArgs(runner, workdir) {
+    if (runner === "claude") {
+        return {
+            command: "claude",
+            args: [
+                "-p",
+                "--dangerously-skip-permissions",
+                "--add-dir",
+                workdir,
+                "--input-format",
+                "stream-json",
+                "--output-format",
+                "stream-json",
+            ],
+        };
+    }
+    return {
+        command: "codex",
+        args: ["exec", "--skip-git-repo-check", "--cd", workdir],
+    };
+}
+function buildPrompt(request, deps) {
+    const sections = [];
+    sections.push([
+        "Coding session metadata:",
+        `sessionId: ${request.sessionId ?? "pending"}`,
+        `parentAgent: ${request.parentAgent ?? "unknown"}`,
+        `taskRef: ${request.taskRef ?? "unassigned"}`,
+    ].join("\n"));
+    if (request.stateFile && deps.existsSync(request.stateFile)) {
+        const stateContent = deps.readFileSync(request.stateFile, "utf-8").trim();
+        if (stateContent.length > 0) {
+            sections.push(`State file (${request.stateFile}):\n${stateContent}`);
+        }
+    }
+    sections.push(request.prompt);
+    return sections.join("\n\n---\n\n");
+}
+function spawnCodingProcess(request, deps = {}) {
+    const spawnFn = deps.spawnFn ?? ((command, args, options) => (0, child_process_1.spawn)(command, args, options));
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const readFileSync = deps.readFileSync ?? fs.readFileSync;
+    const prompt = buildPrompt(request, { existsSync, readFileSync });
+    const { command, args } = buildCommandArgs(request.runner, request.workdir);
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.coding_spawn_start",
+        message: "spawning coding session process",
+        meta: { runner: request.runner, workdir: request.workdir },
+    });
+    const proc = spawnFn(command, args, {
+        cwd: request.workdir,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    proc.stdin.write(`${prompt}\n`);
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.coding_spawn_end",
+        message: "spawned coding session process",
+        meta: { runner: request.runner, pid: proc.pid ?? null },
+    });
+    return { process: proc, command, args, prompt };
+}

package/dist/repertoire/coding/tools.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codingToolDefinitions = void 0;
+const index_1 = require("./index");
+const runtime_1 = require("../../nerves/runtime");
+const RUNNERS = ["claude", "codex"];
+function requireArg(args, key) {
+    const value = args[key];
+    if (!value || value.trim().length === 0) {
+        return null;
+    }
+    return value.trim();
+}
+function parseRunner(value) {
+    return RUNNERS.includes(value) ? value : null;
+}
+function optionalArg(args, key) {
+    const raw = args[key];
+    if (!raw)
+        return undefined;
+    const trimmed = raw.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function emitCodingToolEvent(toolName) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.coding_tool_call",
+        message: "coding tool handler invoked",
+        meta: { toolName },
+    });
+}
+const codingSpawnTool = {
+    type: "function",
+    function: {
+        name: "coding_spawn",
+        description: "spawn a coding session using claude/codex and explicit task-threaded guidance",
+        parameters: {
+            type: "object",
+            properties: {
+                runner: { type: "string", enum: ["claude", "codex"] },
+                workdir: { type: "string" },
+                prompt: { type: "string" },
+                taskRef: { type: "string" },
+                scopeFile: { type: "string" },
+                stateFile: { type: "string" },
+            },
+            required: ["runner", "workdir", "prompt", "taskRef"],
+        },
+    },
+};
+const codingStatusTool = {
+    type: "function",
+    function: {
+        name: "coding_status",
+        description: "inspect coding sessions; omit sessionId to list all active/known sessions",
+        parameters: {
+            type: "object",
+            properties: {
+                sessionId: { type: "string" },
+            },
+        },
+    },
+};
+const codingSendInputTool = {
+    type: "function",
+    function: {
+        name: "coding_send_input",
+        description: "send stdin text to an existing coding session",
+        parameters: {
+            type: "object",
+            properties: {
+                sessionId: { type: "string" },
+                input: { type: "string" },
+            },
+            required: ["sessionId", "input"],
+        },
+    },
+};
+const codingKillTool = {
+    type: "function",
+    function: {
+        name: "coding_kill",
+        description: "terminate an existing coding session",
+        parameters: {
+            type: "object",
+            properties: {
+                sessionId: { type: "string" },
+            },
+            required: ["sessionId"],
+        },
+    },
+};
+exports.codingToolDefinitions = [
+    {
+        tool: codingSpawnTool,
+        handler: async (args) => {
+            emitCodingToolEvent("coding_spawn");
+            const rawRunner = requireArg(args, "runner");
+            if (!rawRunner)
+                return "runner is required";
+            const runner = parseRunner(rawRunner);
+            if (!runner)
+                return `invalid runner: ${rawRunner}`;
+            const workdir = requireArg(args, "workdir");
+            if (!workdir)
+                return "workdir is required";
+            const prompt = requireArg(args, "prompt");
+            if (!prompt)
+                return "prompt is required";
+            const taskRef = requireArg(args, "taskRef");
+            if (!taskRef)
+                return "taskRef is required";
+            const request = {
+                runner,
+                workdir,
+                prompt,
+                taskRef,
+            };
+            const scopeFile = optionalArg(args, "scopeFile");
+            if (scopeFile)
+                request.scopeFile = scopeFile;
+            const stateFile = optionalArg(args, "stateFile");
+            if (stateFile)
+                request.stateFile = stateFile;
+            const session = await (0, index_1.getCodingSessionManager)().spawnSession(request);
+            return JSON.stringify(session);
+        },
+    },
+    {
+        tool: codingStatusTool,
+        handler: (args) => {
+            emitCodingToolEvent("coding_status");
+            const manager = (0, index_1.getCodingSessionManager)();
+            const sessionId = requireArg(args, "sessionId");
+            if (!sessionId) {
+                return JSON.stringify(manager.listSessions());
+            }
+            const session = manager.getSession(sessionId);
+            if (!session)
+                return `session not found: ${sessionId}`;
+            return JSON.stringify(session);
+        },
+    },
+    {
+        tool: codingSendInputTool,
+        handler: (args) => {
+            emitCodingToolEvent("coding_send_input");
+            const sessionId = requireArg(args, "sessionId");
+            if (!sessionId)
+                return "sessionId is required";
+            const input = requireArg(args, "input");
+            if (!input)
+                return "input is required";
+            return JSON.stringify((0, index_1.getCodingSessionManager)().sendInput(sessionId, input));
+        },
+    },
+    {
+        tool: codingKillTool,
+        handler: (args) => {
+            emitCodingToolEvent("coding_kill");
+            const sessionId = requireArg(args, "sessionId");
+            if (!sessionId)
+                return "sessionId is required";
+            return JSON.stringify((0, index_1.getCodingSessionManager)().killSession(sessionId));
+        },
+    },
+];

package/dist/repertoire/coding/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/repertoire/data/ado-endpoints.json

@@ -0,0 +1,122 @@
+[
+    {
+        "path": "/_apis/wit/wiql",
+        "method": "POST",
+        "description": "Run a WIQL query to search for work items (read-only, use ado_query)",
+        "params": "query (WIQL string)"
+    },
+    {
+        "path": "/_apis/wit/workitems/{id}",
+        "method": "GET",
+        "description": "Get a single work item by ID",
+        "params": "$expand, fields, asOf"
+    },
+    {
+        "path": "/_apis/wit/workitems?ids={ids}",
+        "method": "GET",
+        "description": "Get multiple work items by IDs (comma-separated)",
+        "params": "ids, fields, $expand, asOf"
+    },
+    {
+        "path": "/{project}/_apis/wit/workitems/${type}",
+        "method": "POST",
+        "description": "Create a new work item of the given type (Bug, Task, User Story, etc.)",
+        "params": "JSON Patch array: [{op, path, value}] for fields like /fields/System.Title"
+    },
+    {
+        "path": "/_apis/wit/workitems/{id}",
+        "method": "PATCH",
+        "description": "Update an existing work item (change title, state, assigned to, etc.)",
+        "params": "JSON Patch array: [{op: replace, path: /fields/System.Title, value: ...}]"
+    },
+    {
+        "path": "/_apis/wit/workitems/{id}",
+        "method": "DELETE",
+        "description": "Delete a work item (moves to recycle bin)",
+        "params": "destroy (boolean, permanently delete)"
+    },
+    {
+        "path": "/_apis/git/repositories",
+        "method": "GET",
+        "description": "List all Git repositories in the organization or project",
+        "params": "project (optional path prefix: /{project}/_apis/git/repositories)"
+    },
+    {
+        "path": "/_apis/git/repositories/{repositoryId}",
+        "method": "GET",
+        "description": "Get a specific Git repository by ID or name",
+        "params": ""
+    },
+    {
+        "path": "/_apis/git/repositories/{repositoryId}/refs",
+        "method": "GET",
+        "description": "List branches and tags for a repository",
+        "params": "filter (e.g. heads/ for branches only), $top"
+    },
+    {
+        "path": "/_apis/git/repositories/{repositoryId}/commits",
+        "method": "GET",
+        "description": "List commits for a repository",
+        "params": "searchCriteria.itemVersion.version (branch), $top, searchCriteria.fromDate, searchCriteria.toDate"
+    },
+    {
+        "path": "/_apis/git/repositories/{repositoryId}/pullrequests",
+        "method": "GET",
+        "description": "List pull requests for a repository",
+        "params": "searchCriteria.status (active/completed/abandoned), searchCriteria.creatorId, $top"
+    },
+    {
+        "path": "/_apis/git/repositories/{repositoryId}/pullrequests",
+        "method": "POST",
+        "description": "Create a new pull request",
+        "params": "sourceRefName, targetRefName, title, description"
+    },
+    {
+        "path": "/_apis/git/repositories/{repositoryId}/pullrequests/{pullRequestId}",
+        "method": "GET",
+        "description": "Get a specific pull request by ID",
+        "params": ""
+    },
+    {
+        "path": "/_apis/git/repositories/{repositoryId}/pullrequests/{pullRequestId}",
+        "method": "PATCH",
+        "description": "Update a pull request (change title, description, status, auto-complete)",
+        "params": "title, description, status (active/abandoned/completed), autoCompleteSetBy"
+    },
+    {
+        "path": "/_apis/build/builds",
+        "method": "GET",
+        "description": "List builds (pipeline runs)",
+        "params": "definitions (pipeline ID), statusFilter, resultFilter, $top, branchName"
+    },
+    {
+        "path": "/_apis/build/builds",
+        "method": "POST",
+        "description": "Queue a new build (trigger a pipeline)",
+        "params": "definition.id, sourceBranch, parameters"
+    },
+    {
+        "path": "/_apis/build/builds/{buildId}",
+        "method": "GET",
+        "description": "Get a specific build by ID",
+        "params": ""
+    },
+    {
+        "path": "/_apis/pipelines",
+        "method": "GET",
+        "description": "List pipelines (definitions)",
+        "params": "$top, orderBy"
+    },
+    {
+        "path": "/_apis/pipelines/{pipelineId}/runs",
+        "method": "POST",
+        "description": "Run a pipeline",
+        "params": "resources.repositories.self.refName (branch), templateParameters"
+    },
+    {
+        "path": "/{project}/_apis/wit/queries",
+        "method": "GET",
+        "description": "List saved work item queries (shared and personal)",
+        "params": "$depth, $expand"
+    }
+]