@vibesdotdev/forge 0.0.0-stage → 1.0.0-rc.5

package/dist/tools/tools/forge-issue-list.descriptor.d.ts

@@ -0,0 +1,132 @@
+/**
+ * forge-issue-list descriptor. Safe to import anywhere (no impl).
+ */
+declare const _default: {
+    readonly kind: "tools/tool";
+    readonly id: "forge-issue-list";
+    readonly name: "forge-issue-list";
+    readonly description: "List issues on a git repository.";
+    readonly mcpDescription: "List non-PR issues on a Vibes Forge repository.";
+    readonly hardware: readonly ["consumer", "cloud"];
+    readonly purpose: ["direct", "worker", "mcp", "agent"];
+    readonly category: "forge";
+    readonly subcategory: "issues";
+    readonly safety: "read";
+    readonly tags: readonly ["forge", "git", "issue", "list"];
+    readonly schemas: {
+        readonly input: import("zod").ZodObject<{
+            repo: import("zod").ZodString;
+            type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                task: "task";
+                bug: "bug";
+                research: "research";
+                ops: "ops";
+                doc: "doc";
+            }>>;
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                done: "done";
+                blocked: "blocked";
+                draft: "draft";
+                backlog: "backlog";
+                planned: "planned";
+                in_progress: "in_progress";
+                in_review: "in_review";
+                cancelled: "cancelled";
+            }>>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            items: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                projectId: import("zod").ZodOptional<import("zod").ZodString>;
+                repositoryId: import("zod").ZodOptional<import("zod").ZodString>;
+                issueNumber: import("zod").ZodOptional<import("zod").ZodNumber>;
+                type: import("zod").ZodEnum<{
+                    task: "task";
+                    bug: "bug";
+                    research: "research";
+                    ops: "ops";
+                    doc: "doc";
+                    pr: "pr";
+                }>;
+                title: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                status: import("zod").ZodEnum<{
+                    done: "done";
+                    blocked: "blocked";
+                    draft: "draft";
+                    backlog: "backlog";
+                    planned: "planned";
+                    in_progress: "in_progress";
+                    in_review: "in_review";
+                    cancelled: "cancelled";
+                }>;
+                priority: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    urgent: "urgent";
+                }>>;
+                effortId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                milestoneId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                ownerParticipantId: import("zod").ZodOptional<import("zod").ZodString>;
+                assignedParticipantId: import("zod").ZodOptional<import("zod").ZodString>;
+                tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                links: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    kind: import("zod").ZodString;
+                    id: import("zod").ZodString;
+                    source: import("zod").ZodString;
+                    role: import("zod").ZodDefault<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>>;
+                pr: import("zod").ZodOptional<import("zod").ZodObject<{
+                    sourceRef: import("zod").ZodString;
+                    targetRef: import("zod").ZodString;
+                    mergeBase: import("zod").ZodOptional<import("zod").ZodString>;
+                    headSha: import("zod").ZodOptional<import("zod").ZodString>;
+                    mergeCommitSha: import("zod").ZodOptional<import("zod").ZodString>;
+                    state: import("zod").ZodEnum<{
+                        open: "open";
+                        draft: "draft";
+                        merged: "merged";
+                        closed: "closed";
+                    }>;
+                    ciStatus: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        success: "success";
+                        error: "error";
+                        pending: "pending";
+                        failure: "failure";
+                    }>>;
+                    stack: import("zod").ZodOptional<import("zod").ZodObject<{
+                        id: import("zod").ZodUUID;
+                        stackNumber: import("zod").ZodNumber;
+                        position: import("zod").ZodNumber;
+                        size: import("zod").ZodNumber;
+                        trunkRef: import("zod").ZodString;
+                        state: import("zod").ZodEnum<{
+                            active: "active";
+                            merged: "merged";
+                            merging: "merging";
+                            dissolved: "dissolved";
+                        }>;
+                        health: import("zod").ZodEnum<{
+                            clean: "clean";
+                            "restack-required": "restack-required";
+                            conflicted: "conflicted";
+                        }>;
+                        landingPolicy: import("zod").ZodEnum<{
+                            "batch-allowed": "batch-allowed";
+                            "one-layer-at-a-time": "one-layer-at-a-time";
+                        }>;
+                        revision: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$loose>>;
+                metadata: import("zod").ZodOptional<import("zod").ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, import("zod/v4/core").$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+                createdAt: import("zod").ZodOptional<import("zod").ZodString>;
+                updatedAt: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/core").$strip>;
+    };
+};
+export default _default;
+//# sourceMappingURL=forge-issue-list.descriptor.d.ts.map

package/dist/tools/tools/forge-issue-list.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-issue-list.descriptor.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-issue-list.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKH,wBAgBG"}

package/dist/tools/tools/forge-issue-list.descriptor.js

@@ -0,0 +1,23 @@
+/**
+ * forge-issue-list descriptor. Safe to import anywhere (no impl).
+ */
+import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+import { IssueListInputSchema, IssueListOutputSchema } from "./schemas.js";
+export default createRuntimeAsset({
+    kind: 'tools/tool',
+    id: 'forge-issue-list',
+    name: 'forge-issue-list',
+    description: 'List issues on a git repository.',
+    mcpDescription: 'List non-PR issues on a Vibes Forge repository.',
+    hardware: ['consumer', 'cloud'],
+    purpose: ['direct', 'worker', 'mcp', 'agent'],
+    category: 'forge',
+    subcategory: 'issues',
+    safety: 'read',
+    tags: ['forge', 'git', 'issue', 'list'],
+    schemas: {
+        input: IssueListInputSchema,
+        output: IssueListOutputSchema
+    }
+});
+//# sourceMappingURL=forge-issue-list.descriptor.js.map

package/dist/tools/tools/forge-issue-list.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-issue-list.descriptor.js","sourceRoot":"","sources":["../../../src/tools/tools/forge-issue-list.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE3E,eAAe,kBAAkB,CAAC;IACjC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,kBAAkB;IACtB,IAAI,EAAE,kBAAkB;IACxB,WAAW,EAAE,kCAAkC;IAC/C,cAAc,EAAE,iDAAiD;IACjE,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC;IAC7C,QAAQ,EAAE,OAAO;IACjB,WAAW,EAAE,QAAQ;IACrB,MAAM,EAAE,MAAM;IACd,IAAI,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC;IACvC,OAAO,EAAE;QACR,KAAK,EAAE,oBAAoB;QAC3B,MAAM,EAAE,qBAAqB;KAC7B;CACD,CAAC,CAAC"}

package/dist/tools/tools/forge-issue-list.impl.d.ts

@@ -0,0 +1,21 @@
+/**
+ * forge-issue-list implementation (lazy-loaded; the unit under test).
+ *
+ * Resolves repo ref -> UUID under the caller's identity, then lists tracking
+ * items through the platform issues route. PRs are filtered out at the tool
+ * boundary so agents get a GitHub-style issue list.
+ */
+import type { VibesRuntime, ToolCallContext } from '@vibesdotdev/kernel';
+import { type IssueListInput, type IssueListOutput } from './schemas.ts';
+import { sendForgeToolRequest } from '../lib/transport.ts';
+import { resolveRepositoryIdScoped } from '../lib/repo-context.ts';
+export interface IssueListDeps {
+    resolveRepositoryIdScoped: typeof resolveRepositoryIdScoped;
+    sendForgeToolRequest: typeof sendForgeToolRequest;
+}
+export declare function executeIssueList(input: IssueListInput, deps?: IssueListDeps, token?: string, runtime?: VibesRuntime): Promise<IssueListOutput>;
+declare const _default: {
+    execute(input: IssueListInput, runtime: VibesRuntime, ctx: ToolCallContext): Promise<IssueListOutput>;
+};
+export default _default;
+//# sourceMappingURL=forge-issue-list.impl.d.ts.map

package/dist/tools/tools/forge-issue-list.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-issue-list.impl.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-issue-list.impl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAEN,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAEN,oBAAoB,EAC2C,MAAM,qBAAqB,CAAC;AAC5F,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,MAAM,WAAW,aAAa;IAC7B,yBAAyB,EAAE,OAAO,yBAAyB,CAAC;IAC5D,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;CAClD;AAOD,wBAAsB,gBAAgB,CACrC,KAAK,EAAE,cAAc,EACrB,IAAI,GAAE,aAA2B,EACjC,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,YAAY,GACpB,OAAO,CAAC,eAAe,CAAC,CAY1B;;mBAIQ,cAAc,WACZ,YAAY,OAChB,eAAe,GAClB,OAAO,CAAC,eAAe,CAAC;;AAL5B,wBASE"}

package/dist/tools/tools/forge-issue-list.impl.js

@@ -0,0 +1,35 @@
+/**
+ * forge-issue-list implementation (lazy-loaded; the unit under test).
+ *
+ * Resolves repo ref -> UUID under the caller's identity, then lists tracking
+ * items through the platform issues route. PRs are filtered out at the tool
+ * boundary so agents get a GitHub-style issue list.
+ */
+import { IssueListInputSchema } from "./schemas.js";
+import { buildIssueListRequest } from "../lib/requests.js";
+import { resolveRepoScopedToolToken, sendForgeToolRequest, requireForgeToolData, forgeToolFailure } from "../lib/transport.js";
+import { resolveRepositoryIdScoped } from "../lib/repo-context.js";
+const defaultDeps = {
+    resolveRepositoryIdScoped,
+    sendForgeToolRequest
+};
+export async function executeIssueList(input, deps = defaultDeps, token, runtime) {
+    const parsed = IssueListInputSchema.parse(input);
+    const scope = token ? { token, runtime } : {};
+    const repoId = await deps.resolveRepositoryIdScoped(parsed.repo, scope);
+    const spec = buildIssueListRequest(repoId, parsed);
+    const res = await deps.sendForgeToolRequest(spec, scope);
+    if (!res.ok) {
+        throw forgeToolFailure('forge-issue-list', res);
+    }
+    return {
+        items: (requireForgeToolData(res, 'forge-issue-list').results ?? []).filter((item) => item.type !== 'pr')
+    };
+}
+export default {
+    async execute(input, runtime, ctx) {
+        const token = await resolveRepoScopedToolToken(runtime, ctx);
+        return executeIssueList(input, defaultDeps, token, runtime);
+    }
+};
+//# sourceMappingURL=forge-issue-list.impl.js.map

package/dist/tools/tools/forge-issue-list.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-issue-list.impl.js","sourceRoot":"","sources":["../../../src/tools/tools/forge-issue-list.impl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACN,oBAAoB,EAGpB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EACN,0BAA0B,EAC1B,oBAAoB,EACG,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5F,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAOnE,MAAM,WAAW,GAAkB;IAClC,yBAAyB;IACzB,oBAAoB;CACpB,CAAC;AAEF,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACrC,KAAqB,EACrB,OAAsB,WAAW,EACjC,KAAc,EACd,OAAsB;IAEtB,MAAM,MAAM,GAAG,oBAAoB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACjD,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC9C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACxE,MAAM,IAAI,GAAqB,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrE,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAwC,IAAI,EAAE,KAAK,CAAC,CAAC;IAChG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QACb,MAAM,gBAAgB,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC;IACjD,CAAC;IACD,OAAO;QACN,KAAK,EAAE,CAAC,oBAAoB,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC;KACzG,CAAC;AACH,CAAC;AAED,eAAe;IACd,KAAK,CAAC,OAAO,CACZ,KAAqB,EACrB,OAAqB,EACrB,GAAoB;QAEpB,MAAM,KAAK,GAAG,MAAM,0BAA0B,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAC7D,OAAO,gBAAgB,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAC7D,CAAC;CACD,CAAC"}

package/dist/tools/tools/forge-issue-reopen.descriptor.d.ts

@@ -0,0 +1,119 @@
+/**
+ * forge-issue-reopen descriptor. Safe to import anywhere (no impl).
+ */
+declare const _default: {
+    readonly kind: "tools/tool";
+    readonly id: "forge-issue-reopen";
+    readonly name: "forge-issue-reopen";
+    readonly description: "Reopen an issue on a git repository.";
+    readonly mcpDescription: "Reopen a non-PR issue by moving it back to an open tracking status.";
+    readonly hardware: readonly ["consumer", "cloud"];
+    readonly purpose: ["direct", "worker", "mcp", "agent"];
+    readonly category: "forge";
+    readonly subcategory: "issues";
+    readonly safety: "write";
+    readonly tags: readonly ["forge", "git", "issue", "reopen"];
+    readonly schemas: {
+        readonly input: import("zod").ZodObject<{
+            repo: import("zod").ZodString;
+            issueNumber: import("zod").ZodNumber;
+            status: import("zod").ZodDefault<import("zod").ZodEnum<{
+                backlog: "backlog";
+                planned: "planned";
+                in_progress: "in_progress";
+            }>>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            item: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                projectId: import("zod").ZodOptional<import("zod").ZodString>;
+                repositoryId: import("zod").ZodOptional<import("zod").ZodString>;
+                issueNumber: import("zod").ZodOptional<import("zod").ZodNumber>;
+                type: import("zod").ZodEnum<{
+                    task: "task";
+                    bug: "bug";
+                    research: "research";
+                    ops: "ops";
+                    doc: "doc";
+                    pr: "pr";
+                }>;
+                title: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                status: import("zod").ZodEnum<{
+                    done: "done";
+                    blocked: "blocked";
+                    draft: "draft";
+                    backlog: "backlog";
+                    planned: "planned";
+                    in_progress: "in_progress";
+                    in_review: "in_review";
+                    cancelled: "cancelled";
+                }>;
+                priority: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    urgent: "urgent";
+                }>>;
+                effortId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                milestoneId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                ownerParticipantId: import("zod").ZodOptional<import("zod").ZodString>;
+                assignedParticipantId: import("zod").ZodOptional<import("zod").ZodString>;
+                tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                links: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    kind: import("zod").ZodString;
+                    id: import("zod").ZodString;
+                    source: import("zod").ZodString;
+                    role: import("zod").ZodDefault<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>>;
+                pr: import("zod").ZodOptional<import("zod").ZodObject<{
+                    sourceRef: import("zod").ZodString;
+                    targetRef: import("zod").ZodString;
+                    mergeBase: import("zod").ZodOptional<import("zod").ZodString>;
+                    headSha: import("zod").ZodOptional<import("zod").ZodString>;
+                    mergeCommitSha: import("zod").ZodOptional<import("zod").ZodString>;
+                    state: import("zod").ZodEnum<{
+                        open: "open";
+                        draft: "draft";
+                        merged: "merged";
+                        closed: "closed";
+                    }>;
+                    ciStatus: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        success: "success";
+                        error: "error";
+                        pending: "pending";
+                        failure: "failure";
+                    }>>;
+                    stack: import("zod").ZodOptional<import("zod").ZodObject<{
+                        id: import("zod").ZodUUID;
+                        stackNumber: import("zod").ZodNumber;
+                        position: import("zod").ZodNumber;
+                        size: import("zod").ZodNumber;
+                        trunkRef: import("zod").ZodString;
+                        state: import("zod").ZodEnum<{
+                            active: "active";
+                            merged: "merged";
+                            merging: "merging";
+                            dissolved: "dissolved";
+                        }>;
+                        health: import("zod").ZodEnum<{
+                            clean: "clean";
+                            "restack-required": "restack-required";
+                            conflicted: "conflicted";
+                        }>;
+                        landingPolicy: import("zod").ZodEnum<{
+                            "batch-allowed": "batch-allowed";
+                            "one-layer-at-a-time": "one-layer-at-a-time";
+                        }>;
+                        revision: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$loose>>;
+                metadata: import("zod").ZodOptional<import("zod").ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, import("zod/v4/core").$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+                createdAt: import("zod").ZodOptional<import("zod").ZodString>;
+                updatedAt: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>;
+        }, import("zod/v4/core").$strip>;
+    };
+};
+export default _default;
+//# sourceMappingURL=forge-issue-reopen.descriptor.d.ts.map

package/dist/tools/tools/forge-issue-reopen.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-issue-reopen.descriptor.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-issue-reopen.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKH,wBAgBG"}

package/dist/tools/tools/forge-issue-reopen.descriptor.js

@@ -0,0 +1,23 @@
+/**
+ * forge-issue-reopen descriptor. Safe to import anywhere (no impl).
+ */
+import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+import { IssueReopenInputSchema, IssueReopenOutputSchema } from "./schemas.js";
+export default createRuntimeAsset({
+    kind: 'tools/tool',
+    id: 'forge-issue-reopen',
+    name: 'forge-issue-reopen',
+    description: 'Reopen an issue on a git repository.',
+    mcpDescription: 'Reopen a non-PR issue by moving it back to an open tracking status.',
+    hardware: ['consumer', 'cloud'],
+    purpose: ['direct', 'worker', 'mcp', 'agent'],
+    category: 'forge',
+    subcategory: 'issues',
+    safety: 'write',
+    tags: ['forge', 'git', 'issue', 'reopen'],
+    schemas: {
+        input: IssueReopenInputSchema,
+        output: IssueReopenOutputSchema
+    }
+});
+//# sourceMappingURL=forge-issue-reopen.descriptor.js.map

package/dist/tools/tools/forge-issue-reopen.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-issue-reopen.descriptor.js","sourceRoot":"","sources":["../../../src/tools/tools/forge-issue-reopen.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAE/E,eAAe,kBAAkB,CAAC;IACjC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,oBAAoB;IACxB,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EAAE,sCAAsC;IACnD,cAAc,EAAE,qEAAqE;IACrF,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC;IAC7C,QAAQ,EAAE,OAAO;IACjB,WAAW,EAAE,QAAQ;IACrB,MAAM,EAAE,OAAO;IACf,IAAI,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC;IACzC,OAAO,EAAE;QACR,KAAK,EAAE,sBAAsB;QAC7B,MAAM,EAAE,uBAAuB;KAC/B;CACD,CAAC,CAAC"}

package/dist/tools/tools/forge-issue-reopen.impl.d.ts

@@ -0,0 +1,13 @@
+/**
+ * forge-issue-reopen implementation (lazy-loaded; the unit under test).
+ */
+import type { VibesRuntime, ToolCallContext } from '@vibesdotdev/kernel';
+import { type IssueReopenInput, type IssueReopenOutput } from './schemas.ts';
+import { type TrackingMutationDeps } from './forge-tracking-mutations.ts';
+export type IssueReopenDeps = TrackingMutationDeps;
+export declare function executeIssueReopen(input: IssueReopenInput, deps?: IssueReopenDeps, token?: string, runtime?: VibesRuntime): Promise<IssueReopenOutput>;
+declare const _default: {
+    execute(input: IssueReopenInput, runtime: VibesRuntime, ctx: ToolCallContext): Promise<IssueReopenOutput>;
+};
+export default _default;
+//# sourceMappingURL=forge-issue-reopen.impl.d.ts.map

package/dist/tools/tools/forge-issue-reopen.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-issue-reopen.impl.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-issue-reopen.impl.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAEN,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAKN,KAAK,oBAAoB,EACzB,MAAM,+BAA+B,CAAC;AAEvC,MAAM,MAAM,eAAe,GAAG,oBAAoB,CAAC;AAEnD,wBAAsB,kBAAkB,CACvC,KAAK,EAAE,gBAAgB,EACvB,IAAI,GAAE,eAA6C,EACnD,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,YAAY,GACpB,OAAO,CAAC,iBAAiB,CAAC,CAqB5B;;mBAIQ,gBAAgB,WACd,YAAY,OAChB,eAAe,GAClB,OAAO,CAAC,iBAAiB,CAAC;;AAL9B,wBASE"}

package/dist/tools/tools/forge-issue-reopen.impl.js

@@ -0,0 +1,20 @@
+/**
+ * forge-issue-reopen implementation (lazy-loaded; the unit under test).
+ */
+import { IssueReopenInputSchema } from "./schemas.js";
+import { resolveRepoScopedToolToken } from "../lib/transport.js";
+import { assertIssueItem, defaultTrackingMutationDeps, patchTrackingItem, readTrackingItem } from "./forge-tracking-mutations.js";
+export async function executeIssueReopen(input, deps = defaultTrackingMutationDeps, token, runtime) {
+    const parsed = IssueReopenInputSchema.parse(input);
+    const { repoId, item } = await readTrackingItem('forge-issue-reopen', parsed.repo, parsed.issueNumber, deps, token, runtime);
+    assertIssueItem('forge-issue-reopen', parsed.issueNumber, item);
+    const updated = await patchTrackingItem('forge-issue-reopen', repoId, parsed.issueNumber, { status: parsed.status }, deps, token, runtime);
+    return { item: updated };
+}
+export default {
+    async execute(input, runtime, ctx) {
+        const token = await resolveRepoScopedToolToken(runtime, ctx);
+        return executeIssueReopen(input, defaultTrackingMutationDeps, token, runtime);
+    }
+};
+//# sourceMappingURL=forge-issue-reopen.impl.js.map

package/dist/tools/tools/forge-issue-reopen.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-issue-reopen.impl.js","sourceRoot":"","sources":["../../../src/tools/tools/forge-issue-reopen.impl.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACN,sBAAsB,EAGtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EACN,eAAe,EACf,2BAA2B,EAC3B,iBAAiB,EACjB,gBAAgB,EAEhB,MAAM,+BAA+B,CAAC;AAIvC,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACvC,KAAuB,EACvB,OAAwB,2BAA2B,EACnD,KAAc,EACd,OAAsB;IAEtB,MAAM,MAAM,GAAG,sBAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACnD,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,gBAAgB,CAC9C,oBAAoB,EACpB,MAAM,CAAC,IAAI,EACX,MAAM,CAAC,WAAW,EAClB,IAAI,EACJ,KAAK,EACL,OAAO,CACP,CAAC;IACF,eAAe,CAAC,oBAAoB,EAAE,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;IAChE,MAAM,OAAO,GAAG,MAAM,iBAAiB,CACtC,oBAAoB,EACpB,MAAM,EACN,MAAM,CAAC,WAAW,EAClB,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,EACzB,IAAI,EACJ,KAAK,EACL,OAAO,CACP,CAAC;IACF,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AAC1B,CAAC;AAED,eAAe;IACd,KAAK,CAAC,OAAO,CACZ,KAAuB,EACvB,OAAqB,EACrB,GAAoB;QAEpB,MAAM,KAAK,GAAG,MAAM,0BAA0B,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAC7D,OAAO,kBAAkB,CAAC,KAAK,EAAE,2BAA2B,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAC/E,CAAC;CACD,CAAC"}

package/dist/tools/tools/forge-issue-search.descriptor.d.ts

@@ -0,0 +1,129 @@
+/**
+ * forge-issue-search descriptor. Safe to import anywhere (no impl).
+ */
+declare const _default: {
+    readonly kind: "tools/tool";
+    readonly id: "forge-issue-search";
+    readonly name: "forge-issue-search";
+    readonly description: "Search issues on a git repository.";
+    readonly mcpDescription: "Search non-PR issues by text. Required field is q (query is accepted as an alias). Ex: {repo:\"framework\",q:\"timeout\"}.";
+    readonly hardware: readonly ["consumer", "cloud"];
+    readonly purpose: ["direct", "worker", "mcp", "agent"];
+    readonly category: "forge";
+    readonly subcategory: "issues";
+    readonly safety: "read";
+    readonly tags: readonly ["forge", "git", "issue", "search"];
+    readonly schemas: {
+        readonly input: import("zod").ZodObject<{
+            repo: import("zod").ZodString;
+            q: import("zod").ZodOptional<import("zod").ZodString>;
+            query: import("zod").ZodOptional<import("zod").ZodString>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            items: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                projectId: import("zod").ZodOptional<import("zod").ZodString>;
+                repositoryId: import("zod").ZodOptional<import("zod").ZodString>;
+                issueNumber: import("zod").ZodOptional<import("zod").ZodNumber>;
+                type: import("zod").ZodEnum<{
+                    task: "task";
+                    bug: "bug";
+                    research: "research";
+                    ops: "ops";
+                    doc: "doc";
+                    pr: "pr";
+                }>;
+                title: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                status: import("zod").ZodEnum<{
+                    done: "done";
+                    blocked: "blocked";
+                    draft: "draft";
+                    backlog: "backlog";
+                    planned: "planned";
+                    in_progress: "in_progress";
+                    in_review: "in_review";
+                    cancelled: "cancelled";
+                }>;
+                priority: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    urgent: "urgent";
+                }>>;
+                effortId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                milestoneId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                ownerParticipantId: import("zod").ZodOptional<import("zod").ZodString>;
+                assignedParticipantId: import("zod").ZodOptional<import("zod").ZodString>;
+                tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                links: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    kind: import("zod").ZodString;
+                    id: import("zod").ZodString;
+                    source: import("zod").ZodString;
+                    role: import("zod").ZodDefault<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>>;
+                pr: import("zod").ZodOptional<import("zod").ZodObject<{
+                    sourceRef: import("zod").ZodString;
+                    targetRef: import("zod").ZodString;
+                    mergeBase: import("zod").ZodOptional<import("zod").ZodString>;
+                    headSha: import("zod").ZodOptional<import("zod").ZodString>;
+                    mergeCommitSha: import("zod").ZodOptional<import("zod").ZodString>;
+                    state: import("zod").ZodEnum<{
+                        open: "open";
+                        draft: "draft";
+                        merged: "merged";
+                        closed: "closed";
+                    }>;
+                    ciStatus: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        success: "success";
+                        error: "error";
+                        pending: "pending";
+                        failure: "failure";
+                    }>>;
+                    stack: import("zod").ZodOptional<import("zod").ZodObject<{
+                        id: import("zod").ZodUUID;
+                        stackNumber: import("zod").ZodNumber;
+                        position: import("zod").ZodNumber;
+                        size: import("zod").ZodNumber;
+                        trunkRef: import("zod").ZodString;
+                        state: import("zod").ZodEnum<{
+                            active: "active";
+                            merged: "merged";
+                            merging: "merging";
+                            dissolved: "dissolved";
+                        }>;
+                        health: import("zod").ZodEnum<{
+                            clean: "clean";
+                            "restack-required": "restack-required";
+                            conflicted: "conflicted";
+                        }>;
+                        landingPolicy: import("zod").ZodEnum<{
+                            "batch-allowed": "batch-allowed";
+                            "one-layer-at-a-time": "one-layer-at-a-time";
+                        }>;
+                        revision: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$loose>>;
+                metadata: import("zod").ZodOptional<import("zod").ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, import("zod/v4/core").$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+                createdAt: import("zod").ZodOptional<import("zod").ZodString>;
+                updatedAt: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    readonly examples: [{
+        readonly description: "Search by q";
+        readonly input: {
+            readonly repo: "vibesdotdev/framework";
+            readonly q: "timeout";
+        };
+    }, {
+        readonly description: "Search by query alias";
+        readonly input: {
+            readonly repo: "vibesdotdev/framework";
+            readonly query: "timeout";
+        };
+    }];
+};
+export default _default;
+//# sourceMappingURL=forge-issue-search.descriptor.d.ts.map

package/dist/tools/tools/forge-issue-search.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-issue-search.descriptor.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-issue-search.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKH,wBA2BG"}

package/dist/tools/tools/forge-issue-search.descriptor.js

@@ -0,0 +1,33 @@
+/**
+ * forge-issue-search descriptor. Safe to import anywhere (no impl).
+ */
+import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+import { IssueSearchInputSchema, IssueSearchOutputSchema } from "./schemas.js";
+export default createRuntimeAsset({
+    kind: 'tools/tool',
+    id: 'forge-issue-search',
+    name: 'forge-issue-search',
+    description: 'Search issues on a git repository.',
+    mcpDescription: 'Search non-PR issues by text. Required field is q (query is accepted as an alias). Ex: {repo:"framework",q:"timeout"}.',
+    hardware: ['consumer', 'cloud'],
+    purpose: ['direct', 'worker', 'mcp', 'agent'],
+    category: 'forge',
+    subcategory: 'issues',
+    safety: 'read',
+    tags: ['forge', 'git', 'issue', 'search'],
+    schemas: {
+        input: IssueSearchInputSchema,
+        output: IssueSearchOutputSchema
+    },
+    examples: [
+        {
+            description: 'Search by q',
+            input: { repo: 'vibesdotdev/framework', q: 'timeout' }
+        },
+        {
+            description: 'Search by query alias',
+            input: { repo: 'vibesdotdev/framework', query: 'timeout' }
+        }
+    ]
+});
+//# sourceMappingURL=forge-issue-search.descriptor.js.map

package/dist/tools/tools/forge-issue-search.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-issue-search.descriptor.js","sourceRoot":"","sources":["../../../src/tools/tools/forge-issue-search.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAE/E,eAAe,kBAAkB,CAAC;IACjC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,oBAAoB;IACxB,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EAAE,oCAAoC;IACjD,cAAc,EACb,wHAAwH;IACzH,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC;IAC7C,QAAQ,EAAE,OAAO;IACjB,WAAW,EAAE,QAAQ;IACrB,MAAM,EAAE,MAAM;IACd,IAAI,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC;IACzC,OAAO,EAAE;QACR,KAAK,EAAE,sBAAsB;QAC7B,MAAM,EAAE,uBAAuB;KAC/B;IACD,QAAQ,EAAE;QACT;YACC,WAAW,EAAE,aAAa;YAC1B,KAAK,EAAE,EAAE,IAAI,EAAE,uBAAuB,EAAE,CAAC,EAAE,SAAS,EAAE;SACtD;QACD;YACC,WAAW,EAAE,uBAAuB;YACpC,KAAK,EAAE,EAAE,IAAI,EAAE,uBAAuB,EAAE,KAAK,EAAE,SAAS,EAAE;SAC1D;KACD;CACD,CAAC,CAAC"}

package/dist/tools/tools/forge-issue-search.impl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * forge-issue-search implementation (lazy-loaded; the unit under test).
+ */
+import { type VibesRuntime, type ToolCallContext } from '@vibesdotdev/kernel';
+import { type IssueSearchInput, type IssueSearchOutput } from './schemas.ts';
+import { sendForgeToolRequest } from '../lib/transport.ts';
+import { resolveRepositoryIdScoped } from '../lib/repo-context.ts';
+export interface IssueSearchDeps {
+    resolveRepositoryIdScoped: typeof resolveRepositoryIdScoped;
+    sendForgeToolRequest: typeof sendForgeToolRequest;
+}
+export declare function executeIssueSearch(input: IssueSearchInput, deps?: IssueSearchDeps, token?: string, runtime?: VibesRuntime): Promise<IssueSearchOutput>;
+declare const _default: {
+    execute(input: IssueSearchInput, runtime: VibesRuntime, ctx: ToolCallContext): Promise<IssueSearchOutput>;
+};
+export default _default;
+//# sourceMappingURL=forge-issue-search.impl.d.ts.map

package/dist/tools/tools/forge-issue-search.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-issue-search.impl.d.ts","sourceRoot":"","sources":["../../../src/tools/tools/forge-issue-search.impl.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAmB,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC/F,OAAO,EAEN,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAA8B,oBAAoB,EAA0C,MAAM,qBAAqB,CAAC;AAC/H,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,MAAM,WAAW,eAAe;IAC/B,yBAAyB,EAAE,OAAO,yBAAyB,CAAC;IAC5D,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;CAClD;AAOD,wBAAsB,kBAAkB,CACvC,KAAK,EAAE,gBAAgB,EACvB,IAAI,GAAE,eAA6B,EACnC,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,YAAY,GACpB,OAAO,CAAC,iBAAiB,CAAC,CAqB5B;;mBAIQ,gBAAgB,WACd,YAAY,OAChB,eAAe,GAClB,OAAO,CAAC,iBAAiB,CAAC;;AAL9B,wBASE"}