@zibby/skills 0.1.33 → 0.1.35

package/dist/llm-billing.d.ts

@@ -0,0 +1,294 @@
+/**
+ * Fetch OpenAI org costs + usage for the window. Iterates pagination
+ * (page_token) until exhausted.
+ *
+ * Reference: GET /v1/organization/costs
+ *   query: start_time (unix sec), end_time (unix sec), bucket_width=1d,
+ *          group_by[]=project_id&group_by[]=line_item, page
+ *   response shape:
+ *     {
+ *       object: 'page',
+ *       data: [
+ *         { object: 'bucket', start_time, end_time,
+ *           results: [{ amount: { value, currency }, project_id, line_item, ... }] }
+ *       ],
+ *       has_more: boolean,
+ *       next_page: '...'
+ *     }
+ *
+ * We normalize each result row into a NormalizedSpendRecord.
+ *
+ * @param {{ startMs: number, endMs: number, groupBy?: string[] }} opts
+ * @returns {Promise<{ ok: true, items: NormalizedSpendRecord[], rawBuckets: number }>}
+ */
+export function fetchOpenAICosts({ startMs, endMs, groupBy }: {
+    startMs: number;
+    endMs: number;
+    groupBy?: string[];
+}): Promise<{
+    ok: true;
+    items: NormalizedSpendRecord[];
+    rawBuckets: number;
+}>;
+/**
+ * Fetch the OpenAI project catalog (id → name). Useful for the digest
+ * to display "acme-prod" instead of "proj_abc123". Cheap — usually
+ * <50 projects. Returns Map<projectId, projectName>.
+ */
+export function fetchOpenAIProjects(): Promise<Map<any, any>>;
+/**
+ * Fetch Anthropic cost report.
+ *
+ * Reference: GET /v1/organizations/cost_report
+ *   query: starting_at (ISO), ending_at (ISO), bucket=1d,
+ *          group_by[]=workspace_id&group_by[]=model
+ *   headers: x-api-key, anthropic-version: 2023-06-01
+ *   response shape (beta):
+ *     {
+ *       data: [
+ *         { starting_at, ending_at, currency: 'USD',
+ *           results: [{ amount: '0.42', workspace_id, model, ... }] }
+ *       ],
+ *       has_more, next_page
+ *     }
+ *
+ * Anthropic returns cost amounts as decimal strings (cents-precision).
+ * Multiply-by-100 then parse-int → exact-cents arithmetic OK; for the
+ * digest we just parseFloat (drift over 28 days is negligible).
+ */
+export function fetchAnthropicCosts({ startMs, endMs, groupBy }: {
+    startMs: any;
+    endMs: any;
+    groupBy?: string[];
+}): Promise<{
+    ok: boolean;
+    items: {
+        provider: string;
+        day: any;
+        costUsd: number;
+        workspaceId: any;
+        apiKeyId: any;
+        model: any;
+        tokensIn: number;
+        tokensOut: number;
+        cachedTokens: number;
+    }[];
+    rawBuckets: number;
+}>;
+/**
+ * Fetch Anthropic workspace catalog (id → name).
+ */
+export function fetchAnthropicWorkspaces(): Promise<Map<any, any>>;
+/**
+ * Fetch Cursor team daily-usage data. The endpoint returns per-day,
+ * per-user, per-model rolls — we flatten to NormalizedSpendRecord.
+ *
+ * Reference: GET /teams/daily-usage-data
+ *   query: startDate (YYYY-MM-DD), endDate (YYYY-MM-DD)
+ *   header: Authorization: Bearer <admin-key>
+ *   response shape (Cursor Admin API, 2026):
+ *     {
+ *       data: [
+ *         { date, totalCents, userMetrics: [
+ *             { email, totalCents, modelUsage: [
+ *                 { model, requestCount, acceptedLines, suggestedLines } ] } ]
+ *         }
+ *       ]
+ *     }
+ *
+ * acceptanceRate = acceptedLines / suggestedLines (per model per user
+ * per day). The digest aggregates across users for the team-level rate.
+ */
+export function fetchCursorSpend({ startMs, endMs }: {
+    startMs: any;
+    endMs: any;
+}): Promise<{
+    ok: boolean;
+    items: ({
+        provider: string;
+        day: any;
+        costUsd: number;
+        userEmail: any;
+        model: any;
+        requestCount: number;
+        acceptanceRate: number;
+    } | {
+        provider: string;
+        day: any;
+        costUsd: number;
+        userEmail: any;
+        model?: undefined;
+        requestCount?: undefined;
+        acceptanceRate?: undefined;
+    })[];
+    rawBuckets: number;
+}>;
+/**
+ * Pull all three providers in parallel. Returns a per-provider result
+ * map so the analyze node can degrade gracefully when one provider
+ * fails (not connected, key revoked, upstream 500, etc.).
+ *
+ * @param {{ startMs: number, endMs: number }} opts
+ * @returns {Promise<{
+ *   openai:    { ok: true, items: NormalizedSpendRecord[] } | { ok: false, error: string },
+ *   anthropic: { ok: true, items: NormalizedSpendRecord[] } | { ok: false, error: string },
+ *   cursor:    { ok: true, items: NormalizedSpendRecord[] } | { ok: false, error: string },
+ *   totals:    { provider: string, totalUsd: number }[],
+ * }>}
+ */
+export function fetchAllProviders({ startMs, endMs }: {
+    startMs: number;
+    endMs: number;
+}): Promise<{
+    openai: {
+        ok: true;
+        items: NormalizedSpendRecord[];
+    } | {
+        ok: false;
+        error: string;
+    };
+    anthropic: {
+        ok: true;
+        items: NormalizedSpendRecord[];
+    } | {
+        ok: false;
+        error: string;
+    };
+    cursor: {
+        ok: true;
+        items: NormalizedSpendRecord[];
+    } | {
+        ok: false;
+        error: string;
+    };
+    totals: {
+        provider: string;
+        totalUsd: number;
+    }[];
+}>;
+/**
+ * Group an array of normalized records by a key + sum costUsd.
+ * Convenience for analyze nodes — saves writing the same reduce 5x.
+ *
+ * @param {NormalizedSpendRecord[]} items
+ * @param {(item: NormalizedSpendRecord) => string} keyFn
+ * @returns {{ key: string, totalUsd: number, count: number }[]}  sorted desc by totalUsd
+ */
+export function groupByKey(items: NormalizedSpendRecord[], keyFn: (item: NormalizedSpendRecord) => string): {
+    key: string;
+    totalUsd: number;
+    count: number;
+}[];
+/**
+ * Compute mean + stddev over a numeric window. Used by analyze nodes
+ * to flag this-week-vs-baseline anomalies (>2σ).
+ *
+ * @param {number[]} xs
+ * @returns {{ mean: number, stddev: number }}
+ */
+export function meanStddev(xs: number[]): {
+    mean: number;
+    stddev: number;
+};
+/**
+ * Normalized record shape — one entry per (provider × day × dimension)
+ * after each provider's response is unpacked. Optional fields are
+ * provider-specific and may be undefined.
+ *
+ * @typedef {Object} NormalizedSpendRecord
+ * @property {'openai'|'anthropic'|'cursor'} provider
+ * @property {string} day                 ISO date (YYYY-MM-DD)
+ * @property {number} costUsd             USD, positive
+ * @property {string} [projectId]         OpenAI project_id
+ * @property {string} [projectName]       OpenAI project metadata (joined on lookup)
+ * @property {string} [workspaceId]       Anthropic workspace_id
+ * @property {string} [workspaceName]     Anthropic workspace metadata
+ * @property {string} [apiKeyId]          OpenAI / Anthropic api_key_id
+ * @property {string} [userEmail]         Cursor team-member email
+ * @property {string} [model]             Model id (when grouped by model)
+ * @property {number} [tokensIn]
+ * @property {number} [tokensOut]
+ * @property {number} [cachedTokens]
+ * @property {number} [requestCount]      Cursor
+ * @property {number} [acceptanceRate]    Cursor: 0..1
+ */
+/**
+ * Marketplace-gating skill declarations. The id matches the
+ * REQUIRED_INTEGRATION_MAP entry on the backend; the template's node
+ * just declares `skills: [SKILLS.OPENAI_BILLING, ...]` and the bundler
+ * derives required integrations automatically.
+ *
+ * These are intentionally minimal — no MCP tools, no resolve(), no
+ * prompt fragments. The skill object exists ONLY to register the
+ * integration dependency. Runtime behavior lives in the fetch fns below.
+ */
+export const openaiBillingSkill: Readonly<{
+    id: "openai_billing";
+    requiresIntegration: "openai_billing";
+    description: "OpenAI organization billing/usage admin API (paste sk-admin-... key)";
+}>;
+export const anthropicBillingSkill: Readonly<{
+    id: "anthropic_billing";
+    requiresIntegration: "anthropic_billing";
+    description: "Anthropic organization cost/usage admin API (paste sk-ant-admin-... key)";
+}>;
+export const cursorAdminSkill: Readonly<{
+    id: "cursor_admin";
+    requiresIntegration: "cursor_admin";
+    description: "Cursor Team/Enterprise admin API (paste admin key)";
+}>;
+/**
+ * Normalized record shape — one entry per (provider × day × dimension)
+ * after each provider's response is unpacked. Optional fields are
+ * provider-specific and may be undefined.
+ */
+export type NormalizedSpendRecord = {
+    provider: "openai" | "anthropic" | "cursor";
+    /**
+     * ISO date (YYYY-MM-DD)
+     */
+    day: string;
+    /**
+     * USD, positive
+     */
+    costUsd: number;
+    /**
+     * OpenAI project_id
+     */
+    projectId?: string;
+    /**
+     * OpenAI project metadata (joined on lookup)
+     */
+    projectName?: string;
+    /**
+     * Anthropic workspace_id
+     */
+    workspaceId?: string;
+    /**
+     * Anthropic workspace metadata
+     */
+    workspaceName?: string;
+    /**
+     * OpenAI / Anthropic api_key_id
+     */
+    apiKeyId?: string;
+    /**
+     * Cursor team-member email
+     */
+    userEmail?: string;
+    /**
+     * Model id (when grouped by model)
+     */
+    model?: string;
+    tokensIn?: number;
+    tokensOut?: number;
+    cachedTokens?: number;
+    /**
+     * Cursor
+     */
+    requestCount?: number;
+    /**
+     * Cursor: 0..1
+     */
+    acceptanceRate?: number;
+};

package/dist/memory.d.ts

@@ -0,0 +1,137 @@
+export namespace memorySkill {
+    let id: string;
+    let serverName: string;
+    let allowedTools: string[];
+    let envKeys: any[];
+    let description: string;
+    function middleware(): Promise<(s: any, o: any, i: any, a: any) => Promise<any>>;
+    let promptFragment: string;
+    function resolve(): {
+        command: string;
+        args: any[];
+        description: string;
+    };
+    let tools: ({
+        name: string;
+        description: string;
+        input_schema: {
+            type: string;
+            properties: {
+                specPath: {
+                    type: string;
+                    description: string;
+                };
+                limit: {
+                    type: string;
+                    description: string;
+                };
+                pageUrl?: undefined;
+                url?: undefined;
+                fromUrl?: undefined;
+                category?: undefined;
+                content?: undefined;
+                sessionId?: undefined;
+            };
+            required?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        input_schema: {
+            type: string;
+            properties: {
+                pageUrl: {
+                    type: string;
+                    description: string;
+                };
+                limit: {
+                    type: string;
+                    description: string;
+                };
+                specPath?: undefined;
+                url?: undefined;
+                fromUrl?: undefined;
+                category?: undefined;
+                content?: undefined;
+                sessionId?: undefined;
+            };
+            required?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        input_schema: {
+            type: string;
+            properties: {
+                url: {
+                    type: string;
+                    description: string;
+                };
+                limit: {
+                    type: string;
+                    description: string;
+                };
+                specPath?: undefined;
+                pageUrl?: undefined;
+                fromUrl?: undefined;
+                category?: undefined;
+                content?: undefined;
+                sessionId?: undefined;
+            };
+            required?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        input_schema: {
+            type: string;
+            properties: {
+                fromUrl: {
+                    type: string;
+                    description: string;
+                };
+                limit: {
+                    type: string;
+                    description: string;
+                };
+                specPath?: undefined;
+                pageUrl?: undefined;
+                url?: undefined;
+                category?: undefined;
+                content?: undefined;
+                sessionId?: undefined;
+            };
+            required?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        input_schema: {
+            type: string;
+            properties: {
+                category: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                content: {
+                    type: string;
+                    description: string;
+                };
+                specPath: {
+                    type: string;
+                    description: string;
+                };
+                sessionId: {
+                    type: string;
+                    description: string;
+                };
+                limit?: undefined;
+                pageUrl?: undefined;
+                url?: undefined;
+                fromUrl?: undefined;
+            };
+            required: string[];
+        };
+    })[];
+}

package/dist/package.json

@@ -1,29 +1,78 @@
 {
   "name": "@zibby/skills",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "Built-in skill definitions for Zibby test automation framework",
   "type": "module",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
     "./bin/mcp-sentry.mjs": "./bin/mcp-sentry.mjs",
     "./bin/mcp-lark.mjs": "./bin/mcp-lark.mjs",
     "./bin/mcp-slack.mjs": "./bin/mcp-slack.mjs",
-    "./browser": "./dist/browser.js",
-    "./jira": "./dist/jira.js",
-    "./github": "./dist/github.js",
-    "./plane": "./dist/plane.js",
-    "./slack": "./dist/slack.js",
-    "./lark": "./dist/lark.js",
-    "./memory": "./dist/memory.js",
-    "./function": "./dist/function-skill.js",
-    "./integrations": "./dist/integrations.js",
-    "./report": "./dist/report.js",
-    "./llm-billing": "./dist/llm-billing.js",
-    "./sentry": "./dist/sentry.js"
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
+    },
+    "./jira": {
+      "types": "./dist/jira.d.ts",
+      "default": "./dist/jira.js"
+    },
+    "./github": {
+      "types": "./dist/github.d.ts",
+      "default": "./dist/github.js"
+    },
+    "./gitlab": {
+      "types": "./dist/gitlab.d.ts",
+      "default": "./dist/gitlab.js"
+    },
+    "./linear": {
+      "types": "./dist/linear.d.ts",
+      "default": "./dist/linear.js"
+    },
+    "./plane": {
+      "types": "./dist/plane.d.ts",
+      "default": "./dist/plane.js"
+    },
+    "./slack": {
+      "types": "./dist/slack.d.ts",
+      "default": "./dist/slack.js"
+    },
+    "./lark": {
+      "types": "./dist/lark.d.ts",
+      "default": "./dist/lark.js"
+    },
+    "./memory": {
+      "types": "./dist/memory.d.ts",
+      "default": "./dist/memory.js"
+    },
+    "./function": {
+      "types": "./dist/function-skill.d.ts",
+      "default": "./dist/function-skill.js"
+    },
+    "./integrations": {
+      "types": "./dist/integrations.d.ts",
+      "default": "./dist/integrations.js"
+    },
+    "./report": {
+      "types": "./dist/report.d.ts",
+      "default": "./dist/report.js"
+    },
+    "./llm-billing": {
+      "types": "./dist/llm-billing.d.ts",
+      "default": "./dist/llm-billing.js"
+    },
+    "./sentry": {
+      "types": "./dist/sentry.d.ts",
+      "default": "./dist/sentry.js"
+    }
   },
   "scripts": {
-    "build": "node ../scripts/build.mjs",
+    "build": "node ../scripts/build.mjs && npm run build:types",
+    "build:types": "tsc -p tsconfig.types.json",
     "prepack": "node scripts/copy-docs.mjs",
     "lint": "eslint .",
     "lint:fix": "eslint --fix ."
@@ -56,8 +105,8 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@zibby/agent-workflow": "^0.3.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@zibby/agent-workflow": "^0.3.0",
     "better-sqlite3": "^12.6.2",
     "mem0ai": "npm:@zibby/mem0ai@^3.0.5",
     "zod": "^3.23.0 || ^4.0.0"
@@ -73,6 +122,7 @@
     "@eslint/js": "^10.0.1",
     "esbuild": "^0.28.0",
     "eslint": "^10.0.2",
-    "globals": "^17.4.0"
+    "globals": "^17.4.0",
+    "typescript": "^5.9.3"
   }
 }

package/dist/plane.d.ts

@@ -0,0 +1,24 @@
+export namespace planeSkill {
+    let id: string;
+    let serverName: string;
+    let allowedTools: string[];
+    let requiresIntegration: "plane";
+    let envKeys: string[];
+    let description: string;
+    let tools: any[];
+    let promptFragment: string;
+    /**
+     * Spawn the official Plane MCP server over stdio. Reads the api-key
+     * credentials from the env the backend injected (PLANE_API_KEY /
+     * PLANE_WORKSPACE_SLUG / PLANE_BASE_URL). PLANE_BASE_URL is optional —
+     * omitted means the MCP server defaults to https://api.plane.so
+     * (Plane Cloud); set it for self-hosted / Zibby-hosted instances.
+     */
+    function resolve(): {
+        type: string;
+        command: string;
+        args: string[];
+        env: {};
+        description: string;
+    };
+}