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

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

@@ -0,0 +1,212 @@
+[
+    {
+        "path": "/me",
+        "method": "GET",
+        "description": "Get current user's profile (displayName, mail, jobTitle, department, officeLocation)",
+        "params": "$select",
+        "scopes": "User.Read"
+    },
+    {
+        "path": "/me/messages",
+        "method": "GET",
+        "description": "List messages in the signed-in user's mailbox",
+        "params": "$top, $filter, $select, $orderby, $search",
+        "scopes": "Mail.Read"
+    },
+    {
+        "path": "/me/messages/{id}",
+        "method": "GET",
+        "description": "Get a specific message by ID",
+        "params": "$select",
+        "scopes": "Mail.Read"
+    },
+    {
+        "path": "/me/sendMail",
+        "method": "POST",
+        "description": "Send an email message on behalf of the signed-in user",
+        "params": "message (with subject, body, toRecipients), saveToSentItems",
+        "scopes": "Mail.Send"
+    },
+    {
+        "path": "/me/messages/{id}",
+        "method": "PATCH",
+        "description": "Update a message (e.g. mark as read, change category)",
+        "params": "isRead, categories, importance",
+        "scopes": "Mail.ReadWrite"
+    },
+    {
+        "path": "/me/messages/{id}",
+        "method": "DELETE",
+        "description": "Delete a message",
+        "params": "",
+        "scopes": "Mail.ReadWrite"
+    },
+    {
+        "path": "/me/events",
+        "method": "GET",
+        "description": "List calendar events for the signed-in user",
+        "params": "$top, $filter, $select, $orderby, startDateTime, endDateTime",
+        "scopes": "Calendars.Read"
+    },
+    {
+        "path": "/me/events",
+        "method": "POST",
+        "description": "Create a new calendar event",
+        "params": "subject, body, start, end, attendees, location, isOnlineMeeting",
+        "scopes": "Calendars.ReadWrite"
+    },
+    {
+        "path": "/me/events/{id}",
+        "method": "PATCH",
+        "description": "Update an existing calendar event",
+        "params": "subject, body, start, end, attendees, location",
+        "scopes": "Calendars.ReadWrite"
+    },
+    {
+        "path": "/me/events/{id}",
+        "method": "DELETE",
+        "description": "Delete a calendar event",
+        "params": "",
+        "scopes": "Calendars.ReadWrite"
+    },
+    {
+        "path": "/me/calendarView",
+        "method": "GET",
+        "description": "Get calendar view (events in a time range, expands recurring events)",
+        "params": "startDateTime (required), endDateTime (required), $top, $select",
+        "scopes": "Calendars.Read"
+    },
+    {
+        "path": "/me/drive/root/children",
+        "method": "GET",
+        "description": "List files and folders in the user's OneDrive root",
+        "params": "$top, $select, $filter",
+        "scopes": "Files.Read"
+    },
+    {
+        "path": "/me/drive/items/{id}",
+        "method": "GET",
+        "description": "Get metadata for a specific file or folder in OneDrive",
+        "params": "$select",
+        "scopes": "Files.Read"
+    },
+    {
+        "path": "/me/drive/items/{id}/content",
+        "method": "GET",
+        "description": "Download file content from OneDrive",
+        "params": "",
+        "scopes": "Files.Read"
+    },
+    {
+        "path": "/me/drive/root:/{path}:/content",
+        "method": "PUT",
+        "description": "Upload a file to OneDrive by path (small files up to 4MB)",
+        "params": "request body is file content",
+        "scopes": "Files.ReadWrite"
+    },
+    {
+        "path": "/me/drive/items/{id}",
+        "method": "DELETE",
+        "description": "Delete a file or folder from OneDrive",
+        "params": "",
+        "scopes": "Files.ReadWrite"
+    },
+    {
+        "path": "/me/chats",
+        "method": "GET",
+        "description": "List chats for the signed-in user",
+        "params": "$top, $filter, $expand",
+        "scopes": "Chat.Read"
+    },
+    {
+        "path": "/me/chats/{id}/messages",
+        "method": "GET",
+        "description": "List messages in a specific chat",
+        "params": "$top, $filter",
+        "scopes": "Chat.Read"
+    },
+    {
+        "path": "/me/chats/{id}/messages",
+        "method": "POST",
+        "description": "Send a message to a specific chat",
+        "params": "body (with content, contentType)",
+        "scopes": "Chat.ReadWrite"
+    },
+    {
+        "path": "/sites/{siteId}",
+        "method": "GET",
+        "description": "Get a SharePoint site by ID",
+        "params": "$select",
+        "scopes": "Sites.Read.All"
+    },
+    {
+        "path": "/sites/{siteId}/lists",
+        "method": "GET",
+        "description": "List SharePoint lists in a site",
+        "params": "$top, $select",
+        "scopes": "Sites.Read.All"
+    },
+    {
+        "path": "/sites/{siteId}/lists/{listId}/items",
+        "method": "GET",
+        "description": "List items in a SharePoint list",
+        "params": "$top, $filter, $expand, $select",
+        "scopes": "Sites.Read.All"
+    },
+    {
+        "path": "/sites/{siteId}/lists/{listId}/items",
+        "method": "POST",
+        "description": "Create a new item in a SharePoint list",
+        "params": "fields (object with column values)",
+        "scopes": "Sites.ReadWrite.All"
+    },
+    {
+        "path": "/me/contacts",
+        "method": "GET",
+        "description": "List contacts for the signed-in user",
+        "params": "$top, $filter, $select, $orderby",
+        "scopes": "Contacts.Read"
+    },
+    {
+        "path": "/me/contacts",
+        "method": "POST",
+        "description": "Create a new contact",
+        "params": "givenName, surname, emailAddresses, businessPhones, companyName",
+        "scopes": "Contacts.ReadWrite"
+    },
+    {
+        "path": "/search/query",
+        "method": "POST",
+        "description": "Search across Microsoft 365 (messages, files, events, sites)",
+        "params": "requests (array with entityTypes, query.queryString)",
+        "scopes": "Mail.Read, Files.Read, Calendars.Read"
+    },
+    {
+        "path": "/users",
+        "method": "GET",
+        "description": "List users in the organization",
+        "params": "$top, $filter, $select, $search",
+        "scopes": "User.Read.All"
+    },
+    {
+        "path": "/users/{id}",
+        "method": "GET",
+        "description": "Get a specific user's profile by ID or UPN",
+        "params": "$select",
+        "scopes": "User.Read.All"
+    },
+    {
+        "path": "/me/memberOf",
+        "method": "GET",
+        "description": "List groups and directory roles the user is a member of",
+        "params": "$top, $filter",
+        "scopes": "Directory.Read.All"
+    },
+    {
+        "path": "/me/photo/$value",
+        "method": "GET",
+        "description": "Get the signed-in user's profile photo (binary)",
+        "params": "",
+        "scopes": "User.Read"
+    }
+]

package/dist/repertoire/github-client.js

@@ -0,0 +1,64 @@
+"use strict";
+// GitHub API client.
+// Provides a generic githubRequest() for arbitrary GitHub REST API endpoints.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubRequest = githubRequest;
+const api_error_1 = require("../heart/api-error");
+const runtime_1 = require("../nerves/runtime");
+const GITHUB_BASE = "https://api.github.com";
+// Generic GitHub API request. Returns response body as pretty-printed JSON string.
+async function githubRequest(token, method, path, body) {
+    try {
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_start",
+            component: "clients",
+            message: "starting GitHub request",
+            meta: { client: "github", method, path },
+        });
+        const url = `${GITHUB_BASE}${path}`;
+        const opts = {
+            method,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/vnd.github+json",
+                "Content-Type": "application/json",
+            },
+        };
+        if (body)
+            opts.body = body;
+        const res = await fetch(url, opts);
+        if (!res.ok) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "client.error",
+                component: "clients",
+                message: "GitHub request failed",
+                meta: { client: "github", method, path, status: res.status },
+            });
+            return (0, api_error_1.handleApiError)(res, "GitHub", "github");
+        }
+        const data = await res.json();
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_end",
+            component: "clients",
+            message: "GitHub request completed",
+            meta: { client: "github", method, path, success: true },
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (err) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "client.error",
+            component: "clients",
+            message: "GitHub request threw exception",
+            meta: {
+                client: "github",
+                method,
+                path,
+                reason: err instanceof Error ? err.message : String(err),
+            },
+        });
+        return (0, api_error_1.handleApiError)(err, "GitHub", "github");
+    }
+}

package/dist/repertoire/graph-client.js

@@ -0,0 +1,118 @@
+"use strict";
+// Graph API client.
+// Provides a generic graphRequest() for arbitrary endpoints
+// and a thin getProfile() wrapper for backward compatibility.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphRequest = graphRequest;
+exports.getProfile = getProfile;
+const api_error_1 = require("../heart/api-error");
+const runtime_1 = require("../nerves/runtime");
+const GRAPH_BASE = "https://graph.microsoft.com/v1.0";
+// Generic Graph API request. Returns response body as pretty-printed JSON string.
+async function graphRequest(token, method, path, body) {
+    try {
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_start",
+            component: "clients",
+            message: "starting Graph request",
+            meta: { client: "graph", method, path },
+        });
+        const url = `${GRAPH_BASE}${path}`;
+        const opts = {
+            method,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+        };
+        if (body)
+            opts.body = body;
+        const res = await fetch(url, opts);
+        if (!res.ok) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "client.error",
+                component: "clients",
+                message: "Graph request failed",
+                meta: { client: "graph", method, path, status: res.status },
+            });
+            return (0, api_error_1.handleApiError)(res, "Graph", "graph");
+        }
+        const data = await res.json();
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_end",
+            component: "clients",
+            message: "Graph request completed",
+            meta: { client: "graph", method, path, success: true },
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (err) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "client.error",
+            component: "clients",
+            message: "Graph request threw exception",
+            meta: {
+                client: "graph",
+                method,
+                path,
+                reason: err instanceof Error ? err.message : String(err),
+            },
+        });
+        return (0, api_error_1.handleApiError)(err, "Graph", "graph");
+    }
+}
+// Backward-compatible thin wrapper: fetches /me and formats as human-readable text.
+async function getProfile(token) {
+    try {
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_start",
+            component: "clients",
+            message: "starting Graph profile request",
+            meta: { client: "graph", operation: "getProfile" },
+        });
+        const res = await fetch(`${GRAPH_BASE}/me`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "client.error",
+                component: "clients",
+                message: "Graph profile request failed",
+                meta: { client: "graph", operation: "getProfile", status: res.status },
+            });
+            return (0, api_error_1.handleApiError)(res, "Graph", "graph");
+        }
+        const profile = (await res.json());
+        const lines = [
+            `Name: ${profile.displayName}`,
+            `Email: ${profile.mail || "N/A"}`,
+            `Job Title: ${profile.jobTitle || "N/A"}`,
+            `Department: ${profile.department || "N/A"}`,
+            `Office: ${profile.officeLocation || "N/A"}`,
+        ];
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_end",
+            component: "clients",
+            message: "Graph profile request completed",
+            meta: { client: "graph", operation: "getProfile", success: true },
+        });
+        return lines.join("\n");
+    }
+    catch (err) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "client.error",
+            component: "clients",
+            message: "Graph profile request threw exception",
+            meta: {
+                client: "graph",
+                operation: "getProfile",
+                reason: err instanceof Error ? err.message : String(err),
+            },
+        });
+        return (0, api_error_1.handleApiError)(err, "Graph", "graph");
+    }
+}

package/dist/repertoire/skills.js

@@ -0,0 +1,156 @@
+"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.getSkillsDir = getSkillsDir;
+exports.listSkills = listSkills;
+exports.loadSkill = loadSkill;
+exports.getLoadedSkills = getLoadedSkills;
+exports.clearLoadedSkills = clearLoadedSkills;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+// Skills live in {agentRoot}/skills/ directory
+function getSkillsDir() {
+    return path.join((0, identity_1.getAgentRoot)(), "skills");
+}
+// Protocol mirror files live in {agentRoot}/skills/protocols/.
+function getProtocolMirrorDir() {
+    return path.join(getSkillsDir(), "protocols");
+}
+// Canonical protocol source lives in {repoRoot}/subagents/.
+function getCanonicalProtocolsDir() {
+    return path.join((0, identity_1.getRepoRoot)(), "subagents");
+}
+function listMarkdownBasenames(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir)
+        .filter((f) => f.endsWith(".md"))
+        .map((f) => path.basename(f, ".md"))
+        .sort();
+}
+// in-memory store for loaded skills
+const loadedSkills = [];
+function listSkills() {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.load_start",
+        component: "repertoire",
+        message: "listing skills",
+        meta: { operation: "listSkills" },
+    });
+    const baseSkills = listMarkdownBasenames(getSkillsDir());
+    const protocolMirrors = listMarkdownBasenames(getProtocolMirrorDir());
+    const canonicalProtocols = listMarkdownBasenames(getCanonicalProtocolsDir());
+    const skills = [...new Set([...baseSkills, ...protocolMirrors, ...canonicalProtocols])].sort();
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.load_end",
+        component: "repertoire",
+        message: "listed skills",
+        meta: { operation: "listSkills", count: skills.length },
+    });
+    return skills;
+}
+function loadSkill(skillName) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.load_start",
+        component: "repertoire",
+        message: "loading skill",
+        meta: { operation: "loadSkill", skill: skillName },
+    });
+    const directSkillPath = path.join(getSkillsDir(), `${skillName}.md`);
+    const protocolMirrorPath = path.join(getProtocolMirrorDir(), `${skillName}.md`);
+    const canonicalProtocolPath = path.join(getCanonicalProtocolsDir(), `${skillName}.md`);
+    let resolvedPath = null;
+    // 1) Direct agent skill.
+    if (fs.existsSync(directSkillPath)) {
+        resolvedPath = directSkillPath;
+    }
+    // 2) Protocol mirror in bundle.
+    else if (fs.existsSync(protocolMirrorPath)) {
+        resolvedPath = protocolMirrorPath;
+    }
+    // 3) Canonical protocol fallback.
+    else if (fs.existsSync(canonicalProtocolPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "repertoire.error",
+            component: "repertoire",
+            message: "protocol mirror missing; using canonical fallback",
+            meta: {
+                operation: "loadSkill",
+                skill: skillName,
+                mirrorPath: protocolMirrorPath,
+                canonicalPath: canonicalProtocolPath,
+            },
+        });
+        resolvedPath = canonicalProtocolPath;
+    }
+    if (!resolvedPath) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "repertoire.error",
+            component: "repertoire",
+            message: "skill not found",
+            meta: {
+                operation: "loadSkill",
+                skill: skillName,
+                checkedPaths: [directSkillPath, protocolMirrorPath, canonicalProtocolPath],
+            },
+        });
+        throw new Error(`skill '${skillName}' not found in:\n` +
+            `- ${directSkillPath}\n` +
+            `- ${protocolMirrorPath}\n` +
+            `- ${canonicalProtocolPath}`);
+    }
+    const content = fs.readFileSync(resolvedPath, "utf-8");
+    if (!loadedSkills.includes(skillName)) {
+        loadedSkills.push(skillName);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.load_end",
+        component: "repertoire",
+        message: "loaded skill",
+        meta: { operation: "loadSkill", skill: skillName, path: resolvedPath },
+    });
+    return content;
+}
+function getLoadedSkills() {
+    return [...loadedSkills];
+}
+function clearLoadedSkills() {
+    loadedSkills.length = 0;
+}

package/dist/repertoire/tasks/board.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTaskBoard = buildTaskBoard;
+exports.boardStatus = boardStatus;
+exports.boardAction = boardAction;
+exports.boardDeps = boardDeps;
+exports.boardSessions = boardSessions;
+const runtime_1 = require("../../nerves/runtime");
+const transitions_1 = require("./transitions");
+const BOARD_STATUS_ORDER = [
+    "blocked",
+    "processing",
+    "collaborating",
+    "drafting",
+    "validating",
+    "paused",
+    "done",
+];
+function compactName(task) {
+    const suffix = task.stem.replace(/^\d{4}-\d{2}-\d{2}-\d{4}-/, "");
+    return suffix.length > 0 ? suffix : task.stem;
+}
+function groupByStatus(tasks) {
+    const grouped = {
+        drafting: [],
+        processing: [],
+        validating: [],
+        collaborating: [],
+        paused: [],
+        blocked: [],
+        done: [],
+    };
+    for (const task of tasks) {
+        grouped[task.status].push(compactName(task));
+    }
+    for (const status of transitions_1.TASK_VALID_STATUSES) {
+        grouped[status].sort();
+    }
+    return grouped;
+}
+function unresolvedDependencies(index) {
+    const stems = new Set(index.tasks.map((task) => task.stem));
+    const unresolved = [];
+    for (const task of index.tasks) {
+        const deps = Array.isArray(task.frontmatter.depends_on) ? task.frontmatter.depends_on : [];
+        for (const dep of deps) {
+            if (typeof dep === "string" && dep.trim() && !stems.has(dep)) {
+                unresolved.push(`${task.stem} -> missing ${dep}`);
+            }
+        }
+    }
+    return unresolved.sort();
+}
+function activeSessionLines(tasks) {
+    const active = tasks.filter((task) => {
+        const session = task.frontmatter.active_session;
+        const codingSession = task.frontmatter.coding_session;
+        return Boolean(session) || Boolean(codingSession);
+    });
+    return active.map((task) => task.stem).sort();
+}
+function actionRequired(index, byStatus) {
+    const actions = [...index.parseErrors, ...index.invalidFilenames.map((filePath) => `bad filename: ${filePath}`)];
+    if (byStatus.blocked.length > 0) {
+        actions.push(`blocked tasks: ${byStatus.blocked.join(", ")}`);
+    }
+    const missingCategory = index.tasks
+        .filter((task) => !task.category || !task.category.trim())
+        .map((task) => `missing category: ${task.stem}`);
+    return [...actions, ...missingCategory];
+}
+function buildTaskBoard(index) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.step_start",
+        component: "mind",
+        message: "building task board",
+        meta: { taskCount: index.tasks.length },
+    });
+    const byStatus = groupByStatus(index.tasks);
+    const counts = transitions_1.TASK_VALID_STATUSES.map((status) => `${status}:${byStatus[status].length}`).join(" ");
+    const processing = byStatus.processing.length > 0 ? `\n processing: ${byStatus.processing.join(", ")}` : "";
+    const blocked = byStatus.blocked.length > 0 ? `\n blocked: ${byStatus.blocked.join(", ")}` : "";
+    const compact = `[Tasks] ${counts}${processing}${blocked}`;
+    const fullLines = [];
+    for (const status of BOARD_STATUS_ORDER) {
+        const names = byStatus[status];
+        if (status === "done" && names.length === 0)
+            continue;
+        fullLines.push(`## ${status}`);
+        fullLines.push(names.length > 0 ? names.map((name) => `- ${name}`).join("\n") : "- (none)");
+    }
+    const unresolved = unresolvedDependencies(index);
+    if (unresolved.length > 0) {
+        fullLines.push("## dependencies");
+        fullLines.push(unresolved.map((line) => `- ${line}`).join("\n"));
+    }
+    const active = activeSessionLines(index.tasks);
+    if (active.length > 0) {
+        fullLines.push("## active sessions");
+        fullLines.push(active.map((line) => `- ${line}`).join("\n"));
+    }
+    return {
+        compact,
+        full: fullLines.join("\n\n"),
+        byStatus,
+        actionRequired: actionRequired(index, byStatus),
+        unresolvedDependencies: unresolved,
+        activeSessions: active,
+    };
+}
+function boardStatus(board, status) {
+    return board.byStatus[status] ?? [];
+}
+function boardAction(board) {
+    return board.actionRequired;
+}
+function boardDeps(board) {
+    return board.unresolvedDependencies;
+}
+function boardSessions(board) {
+    return board.activeSessions;
+}