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

package/dist/repertoire/ado-client.js

@@ -0,0 +1,211 @@
+"use strict";
+// Azure DevOps API client.
+// Provides a generic adoRequest() for arbitrary endpoints
+// and a thin queryWorkItems() wrapper for backward compatibility.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adoRequest = adoRequest;
+exports.queryWorkItems = queryWorkItems;
+exports.discoverOrganizations = discoverOrganizations;
+exports.discoverProjects = discoverProjects;
+const api_error_1 = require("../heart/api-error");
+const runtime_1 = require("../nerves/runtime");
+const ADO_BASE = "https://dev.azure.com";
+const VSSPS_BASE = "https://app.vssps.visualstudio.com";
+const DEFAULT_API_VERSION = "api-version=7.1";
+// Append api-version=7.1 to the URL if not already present.
+function ensureApiVersion(path) {
+    if (path.includes("api-version="))
+        return path;
+    return path.includes("?") ? `${path}&${DEFAULT_API_VERSION}` : `${path}?${DEFAULT_API_VERSION}`;
+}
+// Determine correct Content-Type for ADO requests.
+function resolveContentType(method, path) {
+    const upper = method.toUpperCase();
+    const isWorkItemMutation = (upper === "POST" || upper === "PATCH") &&
+        path.toLowerCase().includes("/_apis/wit/workitems/");
+    return isWorkItemMutation
+        ? "application/json-patch+json"
+        : "application/json";
+}
+// Generic ADO API request. Returns response body as pretty-printed JSON string.
+async function adoRequest(token, method, org, path, body) {
+    try {
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_start",
+            component: "clients",
+            message: "starting ADO request",
+            meta: { client: "ado", method, org, path },
+        });
+        const fullPath = ensureApiVersion(path);
+        const url = `${ADO_BASE}/${org}${fullPath}`;
+        const contentType = resolveContentType(method, path);
+        const opts = {
+            method,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": contentType,
+            },
+        };
+        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: "ADO request failed",
+                meta: { client: "ado", method, org, path, status: res.status },
+            });
+            return (0, api_error_1.handleApiError)(res, "ADO", "ado");
+        }
+        const data = await res.json();
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_end",
+            component: "clients",
+            message: "ADO request completed",
+            meta: { client: "ado", method, org, path, success: true },
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (err) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "client.error",
+            component: "clients",
+            message: "ADO request threw exception",
+            meta: {
+                client: "ado",
+                method,
+                org,
+                path,
+                reason: err instanceof Error ? err.message : String(err),
+            },
+        });
+        return (0, api_error_1.handleApiError)(err, "ADO", "ado");
+    }
+}
+// Backward-compatible thin wrapper: runs WIQL query and returns formatted work items.
+async function queryWorkItems(token, org, query) {
+    try {
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_start",
+            component: "clients",
+            message: "starting ADO work item query",
+            meta: { client: "ado", org, operation: "queryWorkItems" },
+        });
+        // Step 1: Run WIQL query to get work item IDs
+        const wiqlRes = await fetch(`${ADO_BASE}/${org}/_apis/wit/wiql?${DEFAULT_API_VERSION}`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ query }),
+        });
+        if (!wiqlRes.ok) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "client.error",
+                component: "clients",
+                message: "ADO WIQL query failed",
+                meta: { client: "ado", org, operation: "queryWorkItems", stage: "wiql", status: wiqlRes.status },
+            });
+            return (0, api_error_1.handleApiError)(wiqlRes, "ADO", "ado");
+        }
+        const wiqlData = (await wiqlRes.json());
+        if (!wiqlData.workItems || wiqlData.workItems.length === 0) {
+            (0, runtime_1.emitNervesEvent)({
+                event: "client.request_end",
+                component: "clients",
+                message: "ADO work item query returned no results",
+                meta: { client: "ado", org, operation: "queryWorkItems", count: 0 },
+            });
+            return "No work items found matching the query.";
+        }
+        // Step 2: Fetch work item details (batch, max 200)
+        const ids = wiqlData.workItems.slice(0, 200).map((wi) => wi.id);
+        const detailRes = await fetch(`${ADO_BASE}/${org}/_apis/wit/workitems?ids=${ids.join(",")}&${DEFAULT_API_VERSION}`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (!detailRes.ok) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "client.error",
+                component: "clients",
+                message: "ADO work item details fetch failed",
+                meta: { client: "ado", org, operation: "queryWorkItems", stage: "details", status: detailRes.status },
+            });
+            return (0, api_error_1.handleApiError)(detailRes, "ADO", "ado");
+        }
+        const detailData = (await detailRes.json());
+        // Format results
+        const lines = detailData.value.map((wi) => {
+            const assignedTo = wi.fields["System.AssignedTo"]?.displayName || "Unassigned";
+            return `#${wi.id}: ${wi.fields["System.Title"]} [${wi.fields["System.State"]}] (${assignedTo})`;
+        });
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_end",
+            component: "clients",
+            message: "ADO work item query completed",
+            meta: { client: "ado", org, operation: "queryWorkItems", count: lines.length },
+        });
+        return lines.join("\n");
+    }
+    catch (err) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "client.error",
+            component: "clients",
+            message: "ADO work item query threw exception",
+            meta: {
+                client: "ado",
+                org,
+                operation: "queryWorkItems",
+                reason: err instanceof Error ? err.message : String(err),
+            },
+        });
+        return (0, api_error_1.handleApiError)(err, "ADO", "ado");
+    }
+}
+// Discover ADO organizations accessible by the authenticated user.
+// 1. Fetches user profile to get publicAlias (member ID)
+// 2. Uses Accounts API to list organizations for that member
+// Throws on API errors (callers handle error presentation).
+async function discoverOrganizations(token) {
+    // Step 1: Get the user's publicAlias from their profile
+    const profileRes = await fetch(`${VSSPS_BASE}/_apis/profile/profiles/me?${DEFAULT_API_VERSION}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!profileRes.ok) {
+        throw new Error(`ADO profile request failed: ${profileRes.status} ${profileRes.statusText}`);
+    }
+    const profile = (await profileRes.json());
+    const memberId = profile.publicAlias;
+    if (!memberId) {
+        throw new Error("ADO profile response missing publicAlias");
+    }
+    // Step 2: List organizations for this member
+    const accountsRes = await fetch(`${VSSPS_BASE}/_apis/accounts?memberId=${memberId}&${DEFAULT_API_VERSION}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!accountsRes.ok) {
+        throw new Error(`ADO accounts request failed: ${accountsRes.status} ${accountsRes.statusText}`);
+    }
+    const data = (await accountsRes.json());
+    return (data.value ?? []).map((a) => a.accountName);
+}
+// Discover projects within an ADO organization.
+// Throws on API errors (callers handle error presentation).
+async function discoverProjects(token, org) {
+    const res = await fetch(`${ADO_BASE}/${org}/_apis/projects?${DEFAULT_API_VERSION}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) {
+        throw new Error(`ADO projects request failed: ${res.status} ${res.statusText}`);
+    }
+    const data = (await res.json());
+    return (data.value ?? []).map((p) => p.name);
+}

package/dist/repertoire/ado-context.js

@@ -0,0 +1,73 @@
+"use strict";
+// ADO context helper -- shared by all semantic ADO tools.
+// Extracts org/project from model-provided args or runs discovery cascade.
+// Re-discovery on 403 naturally handled: scope discovery APIs reflect current access.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAdoContext = resolveAdoContext;
+const ado_client_1 = require("./ado-client");
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Resolve ADO organization and project for a semantic tool.
+ * If org/project are provided by the model, use them directly.
+ * Otherwise, run discovery cascade: discover orgs, auto-select if single,
+ * then discover projects, auto-select if single.
+ *
+ * @param token - ADO OAuth token
+ * @param context - ResolvedContext from the context kernel
+ * @param args - optional org/project from the model
+ */
+async function resolveAdoContext(token, context, args) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.ado_context_resolve",
+        message: "resolving ado context",
+        meta: {},
+    });
+    // Reject if ADO integration is not available
+    if (!context.channel.availableIntegrations.includes("ado")) {
+        return { ok: false, error: "ADO integration is not available in this channel." };
+    }
+    try {
+        // Resolve organization
+        let org = args?.organization;
+        if (!org) {
+            const orgs = await (0, ado_client_1.discoverOrganizations)(token);
+            if (orgs.length === 0) {
+                return { ok: false, error: "No ADO organizations found for this user." };
+            }
+            if (orgs.length === 1) {
+                org = orgs[0];
+            }
+            else {
+                return {
+                    ok: false,
+                    error: `Multiple ADO organizations found. Please specify which one:\n${orgs.map(o => `- ${o}`).join("\n")}`,
+                };
+            }
+        }
+        // Resolve project
+        let project = args?.project;
+        if (!project) {
+            const projects = await (0, ado_client_1.discoverProjects)(token, org);
+            if (projects.length === 0) {
+                return { ok: false, error: `No projects found in organization "${org}".` };
+            }
+            if (projects.length === 1) {
+                project = projects[0];
+            }
+            else {
+                return {
+                    ok: false,
+                    error: `Multiple projects found in "${org}". Please specify which one:\n${projects.map(p => `- ${p}`).join("\n")}`,
+                };
+            }
+        }
+        return { ok: true, organization: org, project };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: `error discovering ADO context: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}