@contractspec/lib.contracts-integrations 2.0.0

package/dist/integrations/providers/jira.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationSpecRegistry } from '../spec';
+export declare const jiraIntegrationSpec: import("..").IntegrationSpec;
+export declare function registerJiraIntegration(registry: IntegrationSpecRegistry): IntegrationSpecRegistry;

package/dist/integrations/providers/jira.js

@@ -0,0 +1,108 @@
+// @bun
+// src/integrations/spec.ts
+import { SpecContractRegistry } from "@contractspec/lib.contracts-spec/registry";
+var integrationKey = (meta) => `${meta.key}.v${meta.version}`;
+
+class IntegrationSpecRegistry extends SpecContractRegistry {
+  constructor(items) {
+    super("integration", items);
+  }
+  getByCategory(category) {
+    return this.list().filter((spec) => spec.meta.category === category);
+  }
+}
+function makeIntegrationSpecKey(meta) {
+  return integrationKey(meta);
+}
+var defineIntegration = (spec) => spec;
+
+// src/integrations/providers/jira.ts
+import { StabilityEnum } from "@contractspec/lib.contracts-spec/ownership";
+var jiraIntegrationSpec = defineIntegration({
+  meta: {
+    key: "project-management.jira",
+    version: "1.0.0",
+    category: "project-management",
+    title: "Jira Cloud",
+    description: "Jira Cloud integration for creating and tracking work items.",
+    domain: "productivity",
+    owners: ["@platform.integrations"],
+    tags: ["project-management", "jira"],
+    stability: StabilityEnum.Beta
+  },
+  supportedModes: ["managed", "byok"],
+  capabilities: {
+    provides: [{ key: "project-management.work-items", version: "1.0.0" }]
+  },
+  configSchema: {
+    schema: {
+      type: "object",
+      required: ["siteUrl"],
+      properties: {
+        siteUrl: {
+          type: "string",
+          description: "Jira Cloud site URL (e.g., https://acme.atlassian.net)."
+        },
+        projectKey: {
+          type: "string",
+          description: "Default Jira project key for new issues."
+        },
+        issueType: {
+          type: "string",
+          description: "Default Jira issue type (e.g., Task, Story)."
+        },
+        defaultLabels: {
+          type: "array",
+          items: { type: "string" },
+          description: "Labels applied to each issue by default."
+        },
+        issueTypeMap: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: "Optional mapping from work item types to Jira issue types."
+        }
+      }
+    },
+    example: {
+      siteUrl: "https://acme.atlassian.net",
+      projectKey: "PM",
+      issueType: "Task"
+    }
+  },
+  secretSchema: {
+    schema: {
+      type: "object",
+      required: ["email", "apiToken"],
+      properties: {
+        email: {
+          type: "string",
+          description: "Jira account email used for API token auth."
+        },
+        apiToken: {
+          type: "string",
+          description: "Jira Cloud API token for the account."
+        }
+      }
+    },
+    example: {
+      email: "user@acme.com",
+      apiToken: "jira_api_token"
+    }
+  },
+  healthCheck: {
+    method: "custom",
+    timeoutMs: 4000
+  },
+  docsUrl: "https://developer.atlassian.com/cloud/jira/platform/rest/v3/intro/",
+  constraints: {},
+  byokSetup: {
+    setupInstructions: "Create a Jira API token and store it with the associated account email."
+  }
+});
+function registerJiraIntegration(registry) {
+  return registry.register(jiraIntegrationSpec);
+}
+export {
+  registerJiraIntegration,
+  jiraIntegrationSpec
+};

package/dist/integrations/providers/linear.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationSpecRegistry } from '../spec';
+export declare const linearIntegrationSpec: import("..").IntegrationSpec;
+export declare function registerLinearIntegration(registry: IntegrationSpecRegistry): IntegrationSpecRegistry;

package/dist/integrations/providers/linear.js

@@ -0,0 +1,107 @@
+// @bun
+// src/integrations/spec.ts
+import { SpecContractRegistry } from "@contractspec/lib.contracts-spec/registry";
+var integrationKey = (meta) => `${meta.key}.v${meta.version}`;
+
+class IntegrationSpecRegistry extends SpecContractRegistry {
+  constructor(items) {
+    super("integration", items);
+  }
+  getByCategory(category) {
+    return this.list().filter((spec) => spec.meta.category === category);
+  }
+}
+function makeIntegrationSpecKey(meta) {
+  return integrationKey(meta);
+}
+var defineIntegration = (spec) => spec;
+
+// src/integrations/providers/linear.ts
+import { StabilityEnum } from "@contractspec/lib.contracts-spec/ownership";
+var linearIntegrationSpec = defineIntegration({
+  meta: {
+    key: "project-management.linear",
+    version: "1.0.0",
+    category: "project-management",
+    title: "Linear",
+    description: "Linear integration for issue tracking and project management workflows.",
+    domain: "productivity",
+    owners: ["@platform.integrations"],
+    tags: ["project-management", "linear"],
+    stability: StabilityEnum.Beta
+  },
+  supportedModes: ["managed", "byok"],
+  capabilities: {
+    provides: [{ key: "project-management.work-items", version: "1.0.0" }]
+  },
+  configSchema: {
+    schema: {
+      type: "object",
+      required: ["teamId"],
+      properties: {
+        teamId: {
+          type: "string",
+          description: "Linear team ID that owns created issues."
+        },
+        projectId: {
+          type: "string",
+          description: "Optional default project ID for new issues."
+        },
+        stateId: {
+          type: "string",
+          description: "Optional default workflow state ID."
+        },
+        assigneeId: {
+          type: "string",
+          description: "Optional default assignee ID."
+        },
+        labelIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional label IDs applied to each issue."
+        },
+        tagLabelMap: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: "Optional mapping of tags to Linear label IDs (tag -> labelId)."
+        }
+      }
+    },
+    example: {
+      teamId: "team_123",
+      projectId: "proj_456",
+      labelIds: ["label_1", "label_2"]
+    }
+  },
+  secretSchema: {
+    schema: {
+      type: "object",
+      required: ["apiKey"],
+      properties: {
+        apiKey: {
+          type: "string",
+          description: "Linear API key (personal or service token)."
+        }
+      }
+    },
+    example: {
+      apiKey: "lin_api_key"
+    }
+  },
+  healthCheck: {
+    method: "custom",
+    timeoutMs: 4000
+  },
+  docsUrl: "https://developers.linear.app",
+  constraints: {},
+  byokSetup: {
+    setupInstructions: "Create a Linear API key with issue:write permission and store it as a secret."
+  }
+});
+function registerLinearIntegration(registry) {
+  return registry.register(linearIntegrationSpec);
+}
+export {
+  registerLinearIntegration,
+  linearIntegrationSpec
+};

package/dist/integrations/providers/llm.d.ts

@@ -0,0 +1,79 @@
+export type LLMRole = 'system' | 'user' | 'assistant' | 'tool';
+export interface LLMTextPart {
+    type: 'text';
+    text: string;
+}
+export interface LLMToolCallPart {
+    type: 'tool-call';
+    id: string;
+    name: string;
+    arguments: string;
+}
+export interface LLMToolResultPart {
+    type: 'tool-result';
+    toolCallId: string;
+    output: string;
+}
+export type LLMContentPart = LLMTextPart | LLMToolCallPart | LLMToolResultPart;
+export interface LLMMessage {
+    role: LLMRole;
+    content: LLMContentPart[];
+    name?: string;
+    toolCallId?: string;
+    metadata?: Record<string, string>;
+}
+export interface LLMToolDefinition {
+    name: string;
+    description?: string;
+    inputSchema: unknown;
+}
+export interface LLMTokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+export interface LLMChatOptions {
+    model?: string;
+    temperature?: number;
+    topP?: number;
+    maxOutputTokens?: number;
+    stopSequences?: string[];
+    responseFormat?: 'text' | 'json';
+    tools?: LLMToolDefinition[];
+    userId?: string;
+    metadata?: Record<string, string>;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface LLMResponse {
+    message: LLMMessage;
+    usage?: LLMTokenUsage;
+    finishReason?: 'stop' | 'length' | 'tool_call' | 'content_filter';
+    raw?: unknown;
+}
+export type LLMStreamChunk = {
+    type: 'message_delta';
+    delta: LLMContentPart;
+    index: number;
+} | {
+    type: 'tool_call';
+    call: LLMToolCallPart;
+    index: number;
+} | {
+    type: 'usage';
+    usage: LLMTokenUsage;
+} | {
+    type: 'error';
+    error: Error;
+} | {
+    type: 'end';
+    response: LLMResponse;
+};
+export interface TokenCountResult {
+    promptTokens: number;
+}
+export interface LLMProvider {
+    chat(messages: LLMMessage[], options?: LLMChatOptions): Promise<LLMResponse>;
+    stream(messages: LLMMessage[], options?: LLMChatOptions): AsyncIterable<LLMStreamChunk>;
+    countTokens(messages: LLMMessage[]): Promise<TokenCountResult>;
+}

package/dist/integrations/providers/llm.js

@@ -0,0 +1 @@
+// @bun

package/dist/integrations/providers/meeting-recorder.d.ts

@@ -0,0 +1,129 @@
+export interface MeetingParticipant {
+    id?: string;
+    externalId?: string;
+    name?: string;
+    email?: string;
+    role?: string;
+    isExternal?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface MeetingRecord {
+    id: string;
+    tenantId: string;
+    connectionId: string;
+    externalId: string;
+    title?: string;
+    summary?: string;
+    organizer?: MeetingParticipant;
+    invitees?: MeetingParticipant[];
+    participants?: MeetingParticipant[];
+    scheduledStartAt?: string;
+    scheduledEndAt?: string;
+    recordingStartAt?: string;
+    recordingEndAt?: string;
+    durationSeconds?: number;
+    meetingUrl?: string;
+    recordingUrl?: string;
+    shareUrl?: string;
+    sourcePlatform?: string;
+    language?: string;
+    transcriptAvailable?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface MeetingTranscriptSegment {
+    index?: number;
+    speakerId?: string;
+    speakerName?: string;
+    speakerEmail?: string;
+    text: string;
+    startTimeMs?: number;
+    endTimeMs?: number;
+    startTime?: string;
+    endTime?: string;
+    confidence?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface MeetingTranscriptRecord {
+    id: string;
+    meetingId: string;
+    tenantId: string;
+    connectionId: string;
+    externalId?: string;
+    format?: string;
+    text?: string;
+    segments?: MeetingTranscriptSegment[];
+    language?: string;
+    sourceUrl?: string;
+    generatedAt?: string;
+    metadata?: Record<string, unknown>;
+    raw?: unknown;
+}
+export interface MeetingRecorderListMeetingsParams {
+    tenantId: string;
+    connectionId?: string;
+    from?: string;
+    to?: string;
+    cursor?: string;
+    pageSize?: number;
+    query?: string;
+    organizerEmail?: string;
+    participantEmail?: string;
+    includeTranscript?: boolean;
+    includeSummary?: boolean;
+}
+export interface MeetingRecorderListMeetingsResult {
+    meetings: MeetingRecord[];
+    nextCursor?: string;
+    hasMore?: boolean;
+}
+export interface MeetingRecorderGetMeetingParams {
+    tenantId: string;
+    meetingId: string;
+    connectionId?: string;
+    includeTranscript?: boolean;
+    includeSummary?: boolean;
+}
+export interface MeetingRecorderGetTranscriptParams {
+    tenantId: string;
+    meetingId: string;
+    connectionId?: string;
+    includeSegments?: boolean;
+    format?: string;
+}
+export interface MeetingRecorderWebhookRequest {
+    headers: Record<string, string | string[] | undefined>;
+    rawBody: string;
+    parsedBody?: unknown;
+}
+export interface MeetingRecorderWebhookEvent {
+    providerKey: string;
+    eventType?: string;
+    meetingId?: string;
+    transcriptId?: string;
+    recordingId?: string;
+    receivedAt?: string;
+    verified?: boolean;
+    payload?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export interface MeetingRecorderWebhookRegistration {
+    url: string;
+    includeTranscript?: boolean;
+    includeSummary?: boolean;
+    includeActionItems?: boolean;
+    includeCrmMatches?: boolean;
+    triggeredFor?: string[];
+}
+export interface MeetingRecorderProvider {
+    listMeetings(params: MeetingRecorderListMeetingsParams): Promise<MeetingRecorderListMeetingsResult>;
+    getMeeting(params: MeetingRecorderGetMeetingParams): Promise<MeetingRecord>;
+    getTranscript(params: MeetingRecorderGetTranscriptParams): Promise<MeetingTranscriptRecord>;
+    parseWebhook?(request: MeetingRecorderWebhookRequest): Promise<MeetingRecorderWebhookEvent>;
+    verifyWebhook?(request: MeetingRecorderWebhookRequest): Promise<boolean>;
+    registerWebhook?(registration: MeetingRecorderWebhookRegistration): Promise<{
+        id: string;
+        secret?: string;
+    }>;
+}

package/dist/integrations/providers/meeting-recorder.js

@@ -0,0 +1 @@
+// @bun

package/dist/integrations/providers/mistral.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationSpecRegistry } from '../spec';
+export declare const mistralIntegrationSpec: import("..").IntegrationSpec;
+export declare function registerMistralIntegration(registry: IntegrationSpecRegistry): IntegrationSpecRegistry;

package/dist/integrations/providers/mistral.js

@@ -0,0 +1,94 @@
+// @bun
+// src/integrations/spec.ts
+import { SpecContractRegistry } from "@contractspec/lib.contracts-spec/registry";
+var integrationKey = (meta) => `${meta.key}.v${meta.version}`;
+
+class IntegrationSpecRegistry extends SpecContractRegistry {
+  constructor(items) {
+    super("integration", items);
+  }
+  getByCategory(category) {
+    return this.list().filter((spec) => spec.meta.category === category);
+  }
+}
+function makeIntegrationSpecKey(meta) {
+  return integrationKey(meta);
+}
+var defineIntegration = (spec) => spec;
+
+// src/integrations/providers/mistral.ts
+import { StabilityEnum } from "@contractspec/lib.contracts-spec/ownership";
+var mistralIntegrationSpec = defineIntegration({
+  meta: {
+    key: "ai-llm.mistral",
+    version: "1.0.0",
+    category: "ai-llm",
+    title: "Mistral Large Language Model",
+    description: "Mistral integration providing chat completions and embedding generation.",
+    domain: "ai",
+    owners: ["platform.ai"],
+    tags: ["ai", "llm", "embeddings"],
+    stability: StabilityEnum.Experimental
+  },
+  supportedModes: ["managed", "byok"],
+  capabilities: {
+    provides: [
+      { key: "ai.chat", version: "1.0.0" },
+      { key: "ai.embeddings", version: "1.0.0" }
+    ]
+  },
+  configSchema: {
+    schema: {
+      type: "object",
+      properties: {
+        model: {
+          type: "string",
+          description: "Default chat completion model (e.g., mistral-large-latest)."
+        },
+        embeddingModel: {
+          type: "string",
+          description: "Embedding model identifier."
+        }
+      }
+    },
+    example: {
+      model: "mistral-large-latest",
+      embeddingModel: "mistral-embed"
+    }
+  },
+  secretSchema: {
+    schema: {
+      type: "object",
+      required: ["apiKey"],
+      properties: {
+        apiKey: {
+          type: "string",
+          description: "Mistral API key with access to chat and embeddings endpoints."
+        }
+      }
+    },
+    example: {
+      apiKey: "mistral-***"
+    }
+  },
+  healthCheck: {
+    method: "custom",
+    timeoutMs: 5000
+  },
+  docsUrl: "https://docs.mistral.ai/platform/endpoints",
+  constraints: {
+    rateLimit: {
+      rpm: 600
+    }
+  },
+  byokSetup: {
+    setupInstructions: "Generate an API key within the Mistral console and ensure the selected models are enabled for the account."
+  }
+});
+function registerMistralIntegration(registry) {
+  return registry.register(mistralIntegrationSpec);
+}
+export {
+  registerMistralIntegration,
+  mistralIntegrationSpec
+};

package/dist/integrations/providers/notion.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationSpecRegistry } from '../spec';
+export declare const notionIntegrationSpec: import("..").IntegrationSpec;
+export declare function registerNotionIntegration(registry: IntegrationSpecRegistry): IntegrationSpecRegistry;

package/dist/integrations/providers/notion.js

@@ -0,0 +1,113 @@
+// @bun
+// src/integrations/spec.ts
+import { SpecContractRegistry } from "@contractspec/lib.contracts-spec/registry";
+var integrationKey = (meta) => `${meta.key}.v${meta.version}`;
+
+class IntegrationSpecRegistry extends SpecContractRegistry {
+  constructor(items) {
+    super("integration", items);
+  }
+  getByCategory(category) {
+    return this.list().filter((spec) => spec.meta.category === category);
+  }
+}
+function makeIntegrationSpecKey(meta) {
+  return integrationKey(meta);
+}
+var defineIntegration = (spec) => spec;
+
+// src/integrations/providers/notion.ts
+import { StabilityEnum } from "@contractspec/lib.contracts-spec/ownership";
+var notionIntegrationSpec = defineIntegration({
+  meta: {
+    key: "project-management.notion",
+    version: "1.0.0",
+    category: "project-management",
+    title: "Notion",
+    description: "Notion integration for creating shared project summaries and task entries.",
+    domain: "productivity",
+    owners: ["@platform.integrations"],
+    tags: ["project-management", "notion"],
+    stability: StabilityEnum.Beta
+  },
+  supportedModes: ["managed", "byok"],
+  capabilities: {
+    provides: [{ key: "project-management.work-items", version: "1.0.0" }]
+  },
+  configSchema: {
+    schema: {
+      type: "object",
+      properties: {
+        databaseId: {
+          type: "string",
+          description: "Optional Notion database ID to store tasks."
+        },
+        summaryParentPageId: {
+          type: "string",
+          description: "Optional parent page ID for summary pages."
+        },
+        titleProperty: {
+          type: "string",
+          description: 'Database title property name (defaults to "Name").'
+        },
+        statusProperty: {
+          type: "string",
+          description: "Database status/select property name."
+        },
+        priorityProperty: {
+          type: "string",
+          description: "Database priority/select property name."
+        },
+        tagsProperty: {
+          type: "string",
+          description: "Database multi-select tags property name."
+        },
+        dueDateProperty: {
+          type: "string",
+          description: "Database date property name for due dates."
+        },
+        descriptionProperty: {
+          type: "string",
+          description: "Database rich-text property for descriptions."
+        }
+      }
+    },
+    example: {
+      databaseId: "xxxxxxxxxxxxxxxx",
+      summaryParentPageId: "yyyyyyyyyyyyyyyy",
+      titleProperty: "Name",
+      statusProperty: "Status"
+    }
+  },
+  secretSchema: {
+    schema: {
+      type: "object",
+      required: ["apiKey"],
+      properties: {
+        apiKey: {
+          type: "string",
+          description: "Notion integration secret token."
+        }
+      }
+    },
+    example: {
+      apiKey: "secret_notion_token"
+    }
+  },
+  healthCheck: {
+    method: "custom",
+    timeoutMs: 4000
+  },
+  docsUrl: "https://developers.notion.com",
+  constraints: {},
+  byokSetup: {
+    setupInstructions: "Create a Notion internal integration, share the target database/page with it, and store the secret token."
+  }
+});
+function registerNotionIntegration(registry) {
+  return registry.register(notionIntegrationSpec);
+}
+export {
+  registerNotionIntegration,
+  notionIntegrationSpec
+};