rig-constellation 0.1.0

package/generated/mcp/handlers/rig_context.handler.ts

@@ -0,0 +1,29 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_context.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_context.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_context.ts';
+
+export const rigContextHandler: ToolHandler = {
+  name: 'rig_context',
+  tier: 'heavy',
+  mainSessionForbidden: true,
+  run: async (args, ctx) => {
+    if (ctx.isMainSession) {
+      throw new ToolError('MAIN_SESSION_FORBIDDEN', 'rig_context cannot run in the main session');
+    }
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_critical_path.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_critical_path.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_critical_path.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_critical_path.ts';
+
+export const rigCriticalPathHandler: ToolHandler = {
+  name: 'rig_critical_path',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_dep_conflicts.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_dep_conflicts.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_dep_conflicts.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_dep_conflicts.ts';
+
+export const rigDepConflictsHandler: ToolHandler = {
+  name: 'rig_dep_conflicts',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_deps.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_deps.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_deps.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_deps.ts';
+
+export const rigDepsHandler: ToolHandler = {
+  name: 'rig_deps',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_drill.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_drill.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_drill.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_drill.ts';
+
+export const rigDrillHandler: ToolHandler = {
+  name: 'rig_drill',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_drop_waypoint.handler.ts

@@ -0,0 +1,34 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_drop_waypoint.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_drop_waypoint.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_drop_waypoint.ts';
+
+export const rigDropWaypointHandler: ToolHandler = {
+  name: 'rig_drop_waypoint',
+  tier: 'write',
+  provenanceRequired: true,
+  requiresRationale: true,
+  run: async (args, ctx) => {
+    if (!ctx.provenance) {
+      throw new ToolError('PROVENANCE_REQUIRED', 'rig_drop_waypoint requires provenance');
+    }
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const rationale = (parsedIn.data as { rationale?: unknown }).rationale;
+    if (typeof rationale !== 'string' || rationale.trim().length === 0) {
+      throw new ToolError('RATIONALE_REQUIRED', 'rig_drop_waypoint requires a non-empty rationale');
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_explore.handler.ts

@@ -0,0 +1,29 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_explore.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_explore.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_explore.ts';
+
+export const rigExploreHandler: ToolHandler = {
+  name: 'rig_explore',
+  tier: 'heavy',
+  mainSessionForbidden: true,
+  run: async (args, ctx) => {
+    if (ctx.isMainSession) {
+      throw new ToolError('MAIN_SESSION_FORBIDDEN', 'rig_explore cannot run in the main session');
+    }
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_files.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_files.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_files.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_files.ts';
+
+export const rigFilesHandler: ToolHandler = {
+  name: 'rig_files',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_focus.handler.ts

@@ -0,0 +1,29 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_focus.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_focus.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_focus.ts';
+
+export const rigFocusHandler: ToolHandler = {
+  name: 'rig_focus',
+  tier: 'write',
+  provenanceRequired: true,
+  run: async (args, ctx) => {
+    if (!ctx.provenance) {
+      throw new ToolError('PROVENANCE_REQUIRED', 'rig_focus requires provenance');
+    }
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_hotspots.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_hotspots.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_hotspots.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_hotspots.ts';
+
+export const rigHotspotsHandler: ToolHandler = {
+  name: 'rig_hotspots',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_hub_of.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_hub_of.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_hub_of.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_hub_of.ts';
+
+export const rigHubOfHandler: ToolHandler = {
+  name: 'rig_hub_of',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_hubs.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_hubs.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_hubs.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_hubs.ts';
+
+export const rigHubsHandler: ToolHandler = {
+  name: 'rig_hubs',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_impact.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_impact.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_impact.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_impact.ts';
+
+export const rigImpactHandler: ToolHandler = {
+  name: 'rig_impact',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_neighbors.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_neighbors.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_neighbors.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_neighbors.ts';
+
+export const rigNeighborsHandler: ToolHandler = {
+  name: 'rig_neighbors',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_node.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_node.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_node.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_node.ts';
+
+export const rigNodeHandler: ToolHandler = {
+  name: 'rig_node',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_phantom_imports.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_phantom_imports.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_phantom_imports.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_phantom_imports.ts';
+
+export const rigPhantomImportsHandler: ToolHandler = {
+  name: 'rig_phantom_imports',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_promote.handler.ts

@@ -0,0 +1,34 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_promote.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_promote.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_promote.ts';
+
+export const rigPromoteHandler: ToolHandler = {
+  name: 'rig_promote',
+  tier: 'write',
+  provenanceRequired: true,
+  requiresRationale: true,
+  run: async (args, ctx) => {
+    if (!ctx.provenance) {
+      throw new ToolError('PROVENANCE_REQUIRED', 'rig_promote requires provenance');
+    }
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const rationale = (parsedIn.data as { rationale?: unknown }).rationale;
+    if (typeof rationale !== 'string' || rationale.trim().length === 0) {
+      throw new ToolError('RATIONALE_REQUIRED', 'rig_promote requires a non-empty rationale');
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_propose_edge.handler.ts

@@ -0,0 +1,34 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_propose_edge.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_propose_edge.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_propose_edge.ts';
+
+export const rigProposeEdgeHandler: ToolHandler = {
+  name: 'rig_propose_edge',
+  tier: 'write',
+  provenanceRequired: true,
+  requiresRationale: true,
+  run: async (args, ctx) => {
+    if (!ctx.provenance) {
+      throw new ToolError('PROVENANCE_REQUIRED', 'rig_propose_edge requires provenance');
+    }
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const rationale = (parsedIn.data as { rationale?: unknown }).rationale;
+    if (typeof rationale !== 'string' || rationale.trim().length === 0) {
+      throw new ToolError('RATIONALE_REQUIRED', 'rig_propose_edge requires a non-empty rationale');
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_pull.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_pull.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_pull.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_pull.ts';
+
+export const rigPullHandler: ToolHandler = {
+  name: 'rig_pull',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_relevant_skills.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_relevant_skills.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_relevant_skills.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_relevant_skills.ts';
+
+export const rigRelevantSkillsHandler: ToolHandler = {
+  name: 'rig_relevant_skills',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_search.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_search.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_search.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_search.ts';
+
+export const rigSearchHandler: ToolHandler = {
+  name: 'rig_search',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_session_token.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_session_token.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_session_token.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_session_token.ts';
+
+export const rigSessionTokenHandler: ToolHandler = {
+  name: 'rig_session_token',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};

package/generated/mcp/handlers/rig_status.handler.ts

@@ -0,0 +1,25 @@
+// GENERATED FILE — DO NOT EDIT.
+// Source: .contracts/tools/rig_status.contract.ts
+// Edit the .contract.ts file(s), then run `bun run gen`.
+
+import type { ToolHandler } from '@rig/mcp/dispatch.ts';
+import { ToolError } from '@rig/mcp/dispatch.ts';
+import contract from '../../../.contracts/tools/rig_status.contract.ts';
+import { run as impl } from '@rig/mcp/tool-impls/rig_status.ts';
+
+export const rigStatusHandler: ToolHandler = {
+  name: 'rig_status',
+  tier: 'light',
+  run: async (args, ctx) => {
+    const parsedIn = contract.input.safeParse(args);
+    if (!parsedIn.success) {
+      throw new ToolError('INPUT_INVALID', parsedIn.error.message);
+    }
+    const out = await impl(parsedIn.data, ctx);
+    const parsedOut = contract.output.safeParse(out);
+    if (!parsedOut.success) {
+      throw new ToolError('OUTPUT_INVALID', parsedOut.error.message);
+    }
+    return parsedOut.data;
+  },
+};