terse-cli 0.2.16 → 0.3.1

package/src/providers/typescript/modules/attio/attio.tools.hbs

@@ -0,0 +1,192 @@
+{{#if toolFile}}
+{{sectionHeader "Attio tools"}}
+
+{{> tools-slice toolFile}}
+
+{{/if}}
+{{sectionHeader "Attio skill"}}
+
+/** Attio — query and upsert records on a CRM object */
+export function attioSkill(opts: { object: AttioObject<any> }): TypedSkill<{{{section.skillToolType}}}> {
+    return new AttioOutputConfig("{{escape section.id}}", opts.object.apiSlug)
+}
+
+{{sectionHeader "Attio internals (generated plumbing — no need to read)"}}
+
+{{#if toolFile}}
+function __normalizeAttioObjectSlug(object: unknown): string {
+    if (object && typeof object === "object" && "apiSlug" in (object as Record<string, unknown>)) {
+        const apiSlug = (object as { apiSlug?: unknown }).apiSlug
+        if (typeof apiSlug === "string" && apiSlug.length > 0) return apiSlug
+    }
+    return typeof object === "string" ? object : ""
+}
+
+function __serializeAttioFilter(filter: unknown): string | null {
+    if (filter === undefined || filter === null) return null
+    return JSON.stringify(filter)
+}
+
+function __serializeAttioValues(values: unknown): string {
+    return JSON.stringify(values ?? {})
+}
+
+function __serializeAttioRecords(records: unknown): string {
+    if (!Array.isArray(records)) return JSON.stringify([])
+    return JSON.stringify(records.filter((record): record is Record<string, unknown> => typeof record === "object" && record !== null && !Array.isArray(record)))
+}
+
+function __enhanceAttioRecord<TObject extends GeneratedAttioObject>(object: TObject, record: unknown): __AttioRecordWithValues<AttioRecordValuesFor<TObject>> | undefined {
+    if (!record || typeof record !== "object") return undefined
+    const values = __getAttioRecordValues<AttioRecordValuesFor<TObject>>(__normalizeAttioObjectSlug(object), record)
+    return { ...values, ...(record as AttioRecordBase), values, attributes: values } as __AttioRecordWithValues<AttioRecordValuesFor<TObject>>
+}
+
+function __requireAttioPayload<T>(value: T | null | undefined, what: string): T {
+    if (value === null || value === undefined) throw new Error("Attio returned a response without the expected " + what + " payload.")
+    return value
+}
+
+function __enhanceAttioQueryResult<TObject extends GeneratedAttioObject>(object: TObject, result: AttioRecordsResult): AttioQueryRecordsResult<TObject> {
+    const records = (result.records || []).map(record => __enhanceAttioRecord(object, record)).filter(Boolean) as Array<AttioRecordFor<TObject>>
+    return { records, count: records.length, offset: result.offset ?? 0 }
+}
+
+function __enhanceAttioSearchResult(result: AttioRecordsResult): AttioSearchRecordsResult {
+    const matches = result.matches ?? []
+    return { matches, count: matches.length }
+}
+
+function __enhanceAttioUpsertResult<TObject extends GeneratedAttioObject>(object: TObject, result: AttioRecordsResult): AttioUpsertRecordResult<TObject> {
+    const records = (result.records || []).map(record => __enhanceAttioRecord(object, record)).filter(Boolean) as Array<AttioRecordFor<TObject>>
+    return { records, count: records.length }
+}
+
+function __enhanceAttioSingleRecordResult<TObject extends GeneratedAttioObject>(object: TObject, result: AttioRecordsResult): AttioSingleRecordResult<TObject> {
+    return __requireAttioPayload(__enhanceAttioRecord(object, result.record), "record")
+}
+
+{{/if}}
+const __attioMetadataKeys = new Set([
+    "active_from",
+    "active_until",
+    "attribute_type",
+    "created_by_actor",
+])
+
+const __attioMultiValueAttributeSlugsByObject: Record<string, readonly string[]> = {
+{{#each section.objects}}
+    "{{escape apiSlug}}": [{{{multiValueSlugsText}}}],
+{{/each}}
+}
+
+const __attioObjectSlugByObjectId: Record<string, string> = {
+{{#each section.objects}}
+    "{{escape objectId}}": "{{escape apiSlug}}",
+{{/each}}
+}
+
+function __flattenAttioLeafValue(value: unknown): unknown {
+    if (value === null || value === undefined) return value
+    if (Array.isArray(value)) return value.map(entry => __flattenAttioLeafValue(entry))
+    if (typeof value !== "object") return value
+    const rawObject = value as Record<string, unknown>
+    if (rawObject.attribute_type === "status") return __toAttioSelectOption(rawObject.status)
+    if (rawObject.attribute_type === "select") return __toAttioSelectOption(rawObject.option)
+    if (typeof rawObject.full_name === "string") return rawObject.full_name
+    if (typeof rawObject.email_address === "string") return rawObject.email_address
+    if (typeof rawObject.domain === "string") return rawObject.domain
+    if (typeof rawObject.phone_number === "string") return rawObject.phone_number
+    if ("value" in rawObject) return __flattenAttioLeafValue(rawObject.value)
+    const dataEntries = Object.entries(rawObject).filter(([key]) => !__attioMetadataKeys.has(key))
+    if (dataEntries.length === 0) return rawObject
+    if (dataEntries.length === 1) return __flattenAttioLeafValue(dataEntries[0][1])
+    return Object.fromEntries(dataEntries.map(([key, entryValue]) => [key, __flattenAttioLeafValue(entryValue)]))
+}
+
+function __toAttioSelectOption(option: unknown): unknown {
+    if (!option || typeof option !== "object") return option
+    const rawOption = option as Record<string, unknown>
+    const rawId = rawOption.id && typeof rawOption.id === "object" ? (rawOption.id as Record<string, unknown>) : undefined
+    const id = rawId?.status_id ?? rawId?.option_id ?? rawOption.id
+    return {
+        id: typeof id === "string" ? id : "",
+        title: typeof rawOption.title === "string" ? rawOption.title : "",
+        is_archived: rawOption.is_archived === true,
+    } satisfies AttioSelectOption
+}
+
+function __flattenAttioAttributeValue(rawValue: unknown, preferArray: boolean): unknown {
+    if (!Array.isArray(rawValue)) return __flattenAttioLeafValue(rawValue)
+    const flattened = rawValue.map(entry => __flattenAttioLeafValue(entry)).filter(entry => entry !== undefined)
+    return preferArray ? flattened : flattened[0]
+}
+
+function __isAttioMultiValueAttribute(objectSlug: string, attributeSlug: string): boolean {
+    return (__attioMultiValueAttributeSlugsByObject[objectSlug] || []).includes(attributeSlug)
+}
+
+function __getAttioRecordValues<TValues extends Record<string, unknown>>(objectSlug: string, record: unknown): TValues {
+    const rawValues = record && typeof record === "object" ? (record as { values?: unknown }).values : undefined
+    if (!rawValues || typeof rawValues !== "object" || Array.isArray(rawValues)) return {} as TValues
+    const flattenedValues: Record<string, unknown> = {}
+    for (const [attributeSlug, rawValue] of Object.entries(rawValues)) {
+        flattenedValues[attributeSlug] = __flattenAttioAttributeValue(rawValue, __isAttioMultiValueAttribute(objectSlug, attributeSlug))
+    }
+    return flattenedValues as TValues
+}
+
+const __attioMultiValueEntrySlugsByList: Record<string, readonly string[]> = {
+{{#each section.lists}}
+    "{{escape apiSlug}}": [{{{multiValueSlugsText}}}],
+    "{{escape listId}}": [{{{multiValueSlugsText}}}],
+{{/each}}
+}
+
+function __getAttioEntryValues<TValues extends Record<string, unknown>>(listKey: string, rawEntryValues: unknown): TValues {
+    if (!rawEntryValues || typeof rawEntryValues !== "object" || Array.isArray(rawEntryValues)) return {} as TValues
+    const flattenedValues: Record<string, unknown> = {}
+    const multiValueSlugs = __attioMultiValueEntrySlugsByList[listKey] || []
+    for (const [attributeSlug, rawValue] of Object.entries(rawEntryValues)) {
+        flattenedValues[attributeSlug] = __flattenAttioAttributeValue(rawValue, multiValueSlugs.includes(attributeSlug))
+    }
+    return flattenedValues as TValues
+}
+
+function __requireAttioListParentObject(list: unknown, parentObjectSlug: string | null | undefined): string {
+    if (parentObjectSlug) return parentObjectSlug
+    if (list && typeof list === "object" && "parentObject" in (list as Record<string, unknown>)) {
+        const parentObject = (list as { parentObject?: unknown }).parentObject
+        if (typeof parentObject === "string" && parentObject.length > 0) return parentObject
+    }
+    throw new Error("parentObjectSlug is required when the list is passed as a plain ID/slug rather than a generated AttioList constant.")
+}
+
+function __enhanceAttioListEntry<TList>(list: TList, entry: unknown): AttioListEntryFor<TList> {
+    const raw = (entry && typeof entry === "object" ? entry : {}) as { entry_values?: unknown }
+    return { ...(raw as object), entry_values: __getAttioEntryValues(__normalizeAttioObjectSlug(list), raw.entry_values) } as AttioListEntryFor<TList>
+}
+
+function __enhanceAttioListEntriesResult<TList>(list: TList, result: AttioListsResult): AttioListEntriesResult<TList> {
+    const entries = (result.entries || []).map(entry => __enhanceAttioListEntry(list, entry))
+    return { entries, count: entries.length, offset: result.offset ?? 0 }
+}
+
+function __enhanceAttioListEntryResult<TList>(list: TList, result: AttioListsResult): AttioListEntryResult<TList> {
+    if (!result.entry) throw new Error("Attio returned a response without the expected list entry payload.")
+    return __enhanceAttioListEntry(list, result.entry)
+}
+
+function __enhanceAttioHistoryResult<TValue>(result: AttioRecordsResult): AttioAttributeHistoryResult<TValue> {
+    const history = (result.history || []).map(entry => ({ active_from: entry.active_from, active_until: entry.active_until, value: __flattenAttioLeafValue(entry) as TValue }))
+    return { history, count: history.length }
+}
+
+registerEventTransform("attio", (event) => {
+    const e = event as { record?: { values?: unknown }; resourceIds?: { object_id?: string } }
+    if (!e?.record?.values) return event
+    const objectId = e.resourceIds?.object_id
+    const slug = objectId ? __attioObjectSlugByObjectId[objectId] : undefined
+    if (!slug) return event
+    return { ...e, record: { ...e.record, values: __getAttioRecordValues(slug, e.record) } }
+})

package/src/providers/typescript/modules/attio/attio.triggers.hbs

@@ -0,0 +1,130 @@
+{{sectionHeader "Attio triggers"}}
+
+{{#each triggerDeclarations}}
+{{{this}}}
+
+{{/each}}
+{{#each section.recordTriggerAliases}}
+{{{this}}}
+{{/each}}
+
+function attioParentObjectFilter(object: GeneratedAttioObject | undefined) {
+    if (!object) return null
+    return { $and: [{ field: "id.object_id", operator: "equals" as const, value: object.objectId }] }
+}
+
+export const attioTriggers = {
+    /** Trigger when a call recording is created */
+    onCallRecordingCreated(): TypedTrigger<AttioCallRecordingCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.CALL_RECORDING_CREATED }])
+    },
+    /** Trigger when a comment is created */
+    onCommentCreated(): TypedTrigger<AttioCommentCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.COMMENT_CREATED }])
+    },
+    /** Trigger when a comment is resolved */
+    onCommentResolved(): TypedTrigger<AttioCommentResolvedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.COMMENT_RESOLVED }])
+    },
+    /** Trigger when a comment is unresolved */
+    onCommentUnresolved(): TypedTrigger<AttioCommentUnresolvedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.COMMENT_UNRESOLVED }])
+    },
+    /** Trigger when a comment is deleted */
+    onCommentDeleted(): TypedTrigger<AttioCommentDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.COMMENT_DELETED }])
+    },
+    /** Trigger when a list is created */
+    onListCreated(): TypedTrigger<AttioListCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_CREATED }])
+    },
+    /** Trigger when a list is updated */
+    onListUpdated(): TypedTrigger<AttioListUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_UPDATED }])
+    },
+    /** Trigger when a list is deleted */
+    onListDeleted(): TypedTrigger<AttioListDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_DELETED }])
+    },
+    /** Trigger when a list attribute is created */
+    onListAttributeCreated(): TypedTrigger<AttioListAttributeCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_ATTRIBUTE_CREATED }])
+    },
+    /** Trigger when a list attribute is updated */
+    onListAttributeUpdated(): TypedTrigger<AttioListAttributeUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_ATTRIBUTE_UPDATED }])
+    },
+    /** Trigger when a list entry is created */
+    onListEntryCreated(): TypedTrigger<AttioListEntryCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_ENTRY_CREATED }])
+    },
+    /** Trigger when a list entry is updated */
+    onListEntryUpdated(): TypedTrigger<AttioListEntryUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_ENTRY_UPDATED }])
+    },
+    /** Trigger when a list entry is deleted */
+    onListEntryDeleted(): TypedTrigger<AttioListEntryDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_ENTRY_DELETED }])
+    },
+    /** Trigger when an object attribute is created */
+    onObjectAttributeCreated(): TypedTrigger<AttioObjectAttributeCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.OBJECT_ATTRIBUTE_CREATED }])
+    },
+    /** Trigger when an object attribute is updated */
+    onObjectAttributeUpdated(): TypedTrigger<AttioObjectAttributeUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.OBJECT_ATTRIBUTE_UPDATED }])
+    },
+    /** Trigger when a note is created */
+    onNoteCreated(): TypedTrigger<AttioNoteCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.NOTE_CREATED }])
+    },
+    /** Trigger when a note's content is updated */
+    onNoteContentUpdated(): TypedTrigger<AttioNoteContentUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.NOTE_CONTENT_UPDATED }])
+    },
+    /** Trigger when a note is updated */
+    onNoteUpdated(): TypedTrigger<AttioNoteUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.NOTE_UPDATED }])
+    },
+    /** Trigger when a note is deleted */
+    onNoteDeleted(): TypedTrigger<AttioNoteDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.NOTE_DELETED }])
+    },
+    /** Trigger when a record is created. Pass `object` to scope to a specific Attio object. */
+    onRecordCreated<T extends GeneratedAttioObject = never>(opts?: { object: T }): TypedTrigger<AttioRecordCreatedTrigger<[T] extends [never] ? GeneratedAttioObject["__recordValues"] : T["__recordValues"]>> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.RECORD_CREATED, filter: attioParentObjectFilter(opts?.object) }])
+    },
+    /** Trigger when records are merged. Pass `object` to scope to a specific Attio object. */
+    onRecordMerged<T extends GeneratedAttioObject = never>(opts?: { object: T }): TypedTrigger<AttioRecordMergedTrigger<[T] extends [never] ? GeneratedAttioObject["__recordValues"] : T["__recordValues"]>> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.RECORD_MERGED, filter: attioParentObjectFilter(opts?.object) }])
+    },
+    /** Trigger when a record is updated. Pass `object` to scope to a specific Attio object. */
+    onRecordUpdated<T extends GeneratedAttioObject = never>(opts?: { object: T }): TypedTrigger<AttioRecordUpdatedTrigger<[T] extends [never] ? GeneratedAttioObject["__recordValues"] : T["__recordValues"]>> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.RECORD_UPDATED, filter: attioParentObjectFilter(opts?.object) }])
+    },
+    /** Trigger when a record is deleted. Pass `object` to scope to a specific Attio object. */
+    onRecordDeleted(opts?: { object?: GeneratedAttioObject }): TypedTrigger<AttioRecordDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.RECORD_DELETED, filter: attioParentObjectFilter(opts?.object) }])
+    },
+    /** Trigger when a task is created */
+    onTaskCreated(): TypedTrigger<AttioTaskCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.TASK_CREATED }])
+    },
+    /** Trigger when a task is updated */
+    onTaskUpdated(): TypedTrigger<AttioTaskUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.TASK_UPDATED }])
+    },
+    /** Trigger when a task is deleted */
+    onTaskDeleted(): TypedTrigger<AttioTaskDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.TASK_DELETED }])
+    },
+    /** Trigger when a workspace member is added */
+    onWorkspaceMemberCreated(): TypedTrigger<AttioWorkspaceMemberCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.WORKSPACE_MEMBER_CREATED }])
+    },
+    /** Trigger on one or more Attio event types. Pass `object` to scope record events to a specific Attio object. */
+    trigger(opts: { eventTypes: AttioEventType[]; object?: GeneratedAttioObject }): TypedTrigger<AttioTrigger> {
+        const filter = attioParentObjectFilter(opts.object)
+        return new AttioInputConfig("{{escape section.id}}", opts.eventTypes.map(eventType => ({ eventType, filter })))
+    },
+}

package/src/providers/typescript/modules/datadog/datadog.tools.hbs

@@ -0,0 +1,16 @@
+{{sectionHeader "Datadog resources"}}
+
+{{> resource-class section.indexClass}}
+
+{{#if toolFile}}
+{{sectionHeader "Datadog tools"}}
+
+{{> tools-slice toolFile}}
+
+{{/if}}
+{{sectionHeader "Datadog skill"}}
+
+/** Datadog — search and analyze logs, optionally scoped to specific indexes */
+export function datadogSkill(opts?: { indexes?: DatadogIndex[] }): TypedSkill<{{{section.skillToolType}}}> {
+    return new DatadogConfig("{{escape section.id}}", opts?.indexes?.map(i => i.name))
+}

package/src/providers/typescript/modules/github/github.tools.hbs

@@ -0,0 +1,68 @@
+{{sectionHeader "GitHub resources"}}
+
+export class GithubOwner {
+    constructor(public readonly name: string) {}
+{{#if section.owners.length}}
+
+{{#each section.owners}}
+    static {{staticName}} = new GithubOwner("{{escape name}}")
+{{/each}}
+{{/if}}
+}
+
+export class Repos {
+    constructor(
+        public readonly repositoryId: number,
+        public readonly name: string,
+        public readonly owner: GithubOwner,
+        public readonly fullName: string
+    ) {}
+{{#if section.repoGroups.length}}
+
+{{#each section.repoGroups}}
+    static {{ownerStaticName}} = {
+{{#each repos}}
+        {{staticName}}: new Repos({{id}}, "{{escape name}}", GithubOwner.{{../ownerStaticName}}, "{{escape fullName}}"),
+{{/each}}
+    } as const
+{{/each}}
+{{/if}}
+}
+
+{{#if repoMappings.length}}
+const __githubRepoNameToFullName = new Map<string, string>([
+{{#each repoMappings}}
+    ["{{escape name}}", "{{escape fullName}}"],
+{{/each}}
+])
+
+function __normalizeGitHubRepos(repo: unknown): string {
+    if (repo && typeof repo === "object" && "fullName" in (repo as Record<string, unknown>)) {
+        const fullName = (repo as { fullName?: unknown }).fullName
+        if (typeof fullName === "string" && fullName.length > 0) return fullName
+    }
+    if (typeof repo === "string") {
+        if (repo.includes("/")) return repo
+        return __githubRepoNameToFullName.get(repo) ?? repo
+    }
+    return String(repo ?? "")
+}
+
+function __normalizeGitHubReposNames(repositories: unknown): string[] {
+    if (!Array.isArray(repositories)) return []
+    return repositories.map(repo => __normalizeGitHubRepos(repo))
+}
+
+{{/if}}
+{{#if toolFile}}
+{{sectionHeader "GitHub tools"}}
+
+{{> tools-slice toolFile}}
+
+{{/if}}
+{{sectionHeader "GitHub skill"}}
+
+/** GitHub — read code and pull requests from the given repositories */
+export function githubSkill(opts: { repos: Repos[] }): TypedSkill<{{{section.skillToolType}}}> {
+    return new GitHubConfig("{{escape section.id}}", opts.repos.map(r => r.repositoryId))
+}

package/src/providers/typescript/modules/github/github.triggers.hbs

@@ -0,0 +1,40 @@
+{{sectionHeader "GitHub triggers"}}
+
+{{#each triggerDeclarations}}
+{{{this}}}
+
+{{/each}}
+export const githubTriggers = {
+    /** Trigger on push to a repository */
+    onPush(opts: { repo: Repos }): TypedTrigger<GithubPushTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PUSH])
+    },
+    /** Trigger when a pull request is opened */
+    onPROpened(opts: { repo: Repos }): TypedTrigger<GithubPROpenedTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PR_OPENED])
+    },
+    /** Trigger when a pull request is merged */
+    onPRMerged(opts: { repo: Repos }): TypedTrigger<GithubPRMergedTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PR_MERGED])
+    },
+    /** Trigger when a pull request is closed */
+    onPRClosed(opts: { repo: Repos }): TypedTrigger<GithubPRClosedTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PR_CLOSED])
+    },
+    /** Trigger when a pull request is synchronized */
+    onPRSynchronized(opts: { repo: Repos }): TypedTrigger<GithubPRSynchronizedTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PR_SYNCHRONIZE])
+    },
+    /** Trigger on any pull request event */
+    onPR(opts: { repo: Repos }): TypedTrigger<GithubPRTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PR_OPENED, GitHubEventType.PR_MERGED, GitHubEventType.PR_CLOSED, GitHubEventType.PR_SYNCHRONIZE])
+    },
+    /** Trigger when a comment is created on an issue or pull request */
+    onIssueComment(opts: { repo: Repos }): TypedTrigger<GithubIssueCommentCreatedTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.ISSUE_COMMENT_CREATED])
+    },
+    /** Trigger on specific GitHub events for the given repositories */
+    trigger(opts: { repos: Repos[]; eventTypes?: GitHubEventType[] }): TypedTrigger<GithubTrigger> {
+        return new GitHubConfig("{{escape section.id}}", opts.repos.map(r => r.repositoryId), opts.eventTypes)
+    },
+}

package/src/providers/typescript/modules/gmail/gmail.tools.hbs

@@ -0,0 +1,17 @@
+{{#if toolFile}}
+{{sectionHeader "Gmail tools"}}
+
+{{> tools-slice toolFile}}
+
+{{/if}}
+{{sectionHeader "Gmail skills"}}
+
+/** Gmail — send emails */
+export function gmailSkill(): TypedSkill<{{{section.skillToolType}}}> {
+    return new GmailOutputConfig("{{escape section.id}}")
+}
+
+/** Gmail — create draft emails (no auto-send) */
+export function gmailDraftSkill(): TypedSkill<{{{section.skillToolType}}}> {
+    return new GmailDraftOutputConfig("{{escape section.id}}")
+}

package/src/providers/typescript/modules/gmail/gmail.triggers.hbs

@@ -0,0 +1,16 @@
+{{sectionHeader "Gmail triggers"}}
+
+{{#each triggerDeclarations}}
+{{{this}}}
+
+{{/each}}
+export const gmailTriggers = {
+    /** Trigger when a new email is received */
+    onEmail(): TypedTrigger<GmailTrigger> {
+        return new GmailConfig("{{escape section.id}}", [GmailEventType.EMAIL_RECEIVED])
+    },
+    /** Trigger on all Gmail events */
+    trigger(opts?: { eventTypes?: GmailEventType[] }): TypedTrigger<GmailTrigger> {
+        return new GmailConfig("{{escape section.id}}", opts?.eventTypes)
+    },
+}

package/src/providers/typescript/modules/hey_reach/hey_reach.tools.hbs

@@ -0,0 +1,9 @@
+{{sectionHeader "HeyReach resources"}}
+
+{{> resource-class section.campaignClass}}
+
+{{#if toolFile}}
+{{sectionHeader "HeyReach tools"}}
+
+{{> tools-slice toolFile}}
+{{/if}}

package/src/providers/typescript/modules/hey_reach/hey_reach.triggers.hbs

@@ -0,0 +1,56 @@
+{{sectionHeader "HeyReach triggers"}}
+
+{{#each triggerDeclarations}}
+{{{this}}}
+
+{{/each}}
+export const heyReachTriggers = {
+    /** Trigger when a connection request is sent */
+    onConnectionRequestSent(opts?: { campaigns?: HeyReachCampaign[] }): TypedTrigger<HeyReachConnectionRequestSentTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", HeyReachEventType.CONNECTION_REQUEST_SENT, (opts?.campaigns ?? []).map(c => c.campaignId))
+    },
+    /** Trigger when a connection request is accepted */
+    onConnectionRequestAccepted(opts?: { campaigns?: HeyReachCampaign[] }): TypedTrigger<HeyReachConnectionRequestAcceptedTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", HeyReachEventType.CONNECTION_REQUEST_ACCEPTED, (opts?.campaigns ?? []).map(c => c.campaignId))
+    },
+    /** Trigger when a LinkedIn message is sent */
+    onMessageSent(opts?: { campaigns?: HeyReachCampaign[] }): TypedTrigger<HeyReachMessageSentTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", HeyReachEventType.MESSAGE_SENT, (opts?.campaigns ?? []).map(c => c.campaignId))
+    },
+    /** Trigger on the first reply to a LinkedIn message */
+    onMessageReplyReceived(opts?: { campaigns?: HeyReachCampaign[] }): TypedTrigger<HeyReachMessageReplyReceivedTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", HeyReachEventType.MESSAGE_REPLY_RECEIVED, (opts?.campaigns ?? []).map(c => c.campaignId))
+    },
+    /** Trigger when an InMail is sent */
+    onInmailSent(opts?: { campaigns?: HeyReachCampaign[] }): TypedTrigger<HeyReachInmailSentTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", HeyReachEventType.INMAIL_SENT, (opts?.campaigns ?? []).map(c => c.campaignId))
+    },
+    /** Trigger on the first reply to an InMail */
+    onInmailReplyReceived(opts?: { campaigns?: HeyReachCampaign[] }): TypedTrigger<HeyReachInmailReplyReceivedTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", HeyReachEventType.INMAIL_REPLY_RECEIVED, (opts?.campaigns ?? []).map(c => c.campaignId))
+    },
+    /** Trigger when a follow is sent */
+    onFollowSent(opts?: { campaigns?: HeyReachCampaign[] }): TypedTrigger<HeyReachFollowSentTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", HeyReachEventType.FOLLOW_SENT, (opts?.campaigns ?? []).map(c => c.campaignId))
+    },
+    /** Trigger when a post is liked */
+    onLikedPost(opts?: { campaigns?: HeyReachCampaign[] }): TypedTrigger<HeyReachLikedPostTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", HeyReachEventType.LIKED_POST, (opts?.campaigns ?? []).map(c => c.campaignId))
+    },
+    /** Trigger when a profile is viewed */
+    onViewedProfile(opts?: { campaigns?: HeyReachCampaign[] }): TypedTrigger<HeyReachViewedProfileTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", HeyReachEventType.VIEWED_PROFILE, (opts?.campaigns ?? []).map(c => c.campaignId))
+    },
+    /** Trigger when a campaign completes */
+    onCampaignCompleted(opts?: { campaigns?: HeyReachCampaign[] }): TypedTrigger<HeyReachCampaignCompletedTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", HeyReachEventType.CAMPAIGN_COMPLETED, (opts?.campaigns ?? []).map(c => c.campaignId))
+    },
+    /** Trigger when lead tags are updated */
+    onLeadTagUpdated(opts?: { campaigns?: HeyReachCampaign[] }): TypedTrigger<HeyReachLeadTagUpdatedTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", HeyReachEventType.LEAD_TAG_UPDATED, (opts?.campaigns ?? []).map(c => c.campaignId))
+    },
+    /** Trigger on specific HeyReach event types */
+    trigger(opts: { campaigns?: HeyReachCampaign[]; eventType: HeyReachEventType }): TypedTrigger<HeyReachTrigger> {
+        return new HeyReachInputConfig("{{escape section.id}}", opts.eventType, (opts.campaigns ?? []).map(c => c.campaignId))
+    },
+}

package/src/providers/typescript/modules/launchdarkly/launchdarkly.tools.hbs

@@ -0,0 +1,16 @@
+{{sectionHeader "LaunchDarkly resources"}}
+
+{{> resource-class section.projectClass}}
+
+{{#if toolFile}}
+{{sectionHeader "LaunchDarkly tools"}}
+
+{{> tools-slice toolFile}}
+
+{{/if}}
+{{sectionHeader "LaunchDarkly skill"}}
+
+/** LaunchDarkly — read and toggle feature flags in a project + environments */
+export function launchDarklySkill(opts: { project: LaunchDarklyProject; environmentKeys: string[] }): TypedSkill<{{{section.skillToolType}}}> {
+    return new LaunchDarklyConfig("{{escape section.id}}", opts.project.projectKey, opts.environmentKeys)
+}

package/src/providers/typescript/modules/linear/linear.tools.hbs

@@ -0,0 +1,23 @@
+{{sectionHeader "Linear resources"}}
+
+{{> resource-class section.teamClass}}
+
+{{> resource-class section.projectClass}}
+
+{{#if toolFile}}
+{{sectionHeader "Linear tools"}}
+
+{{> tools-slice toolFile}}
+
+{{/if}}
+{{sectionHeader "Linear skill"}}
+
+/** Linear — read and write issues, optionally scoped to a team or project */
+export function linearSkill(opts?: { team?: LinearTeam; project?: LinearProject }): TypedSkill<{{{section.skillToolType}}}> {
+    return new LinearOutputConfig(
+        "{{escape section.id}}",
+        opts?.team?.teamId ?? null,
+        opts?.team?.name ?? null,
+        opts?.project?.projectId ?? null
+    )
+}

package/src/providers/typescript/modules/linear/linear.triggers.hbs

@@ -0,0 +1,24 @@
+{{sectionHeader "Linear triggers"}}
+
+{{#each triggerDeclarations}}
+{{{this}}}
+
+{{/each}}
+export const linearTriggers = {
+    /** Trigger when a new issue is created. Optionally scope with `LinearTeam.*` / `LinearProject.*`. */
+    onIssueCreated(opts?: { team?: LinearTeam; project?: LinearProject }): TypedTrigger<LinearIssueCreatedTrigger> {
+        return new LinearInputConfig("{{escape section.id}}", opts?.project?.projectId ?? null, [LinearEventType.ISSUE_CREATED], opts?.team?.teamId ?? null)
+    },
+    /** Trigger when an issue is updated */
+    onIssueUpdated(opts?: { team?: LinearTeam; project?: LinearProject }): TypedTrigger<LinearIssueUpdatedTrigger> {
+        return new LinearInputConfig("{{escape section.id}}", opts?.project?.projectId ?? null, [LinearEventType.ISSUE_UPDATED], opts?.team?.teamId ?? null)
+    },
+    /** Trigger when a comment is added to an issue */
+    onComment(opts?: { team?: LinearTeam; project?: LinearProject }): TypedTrigger<LinearCommentCreatedTrigger> {
+        return new LinearInputConfig("{{escape section.id}}", opts?.project?.projectId ?? null, [LinearEventType.COMMENT_CREATED], opts?.team?.teamId ?? null)
+    },
+    /** Trigger on all Linear events */
+    trigger(opts?: { team?: LinearTeam; project?: LinearProject; eventTypes?: LinearEventType[] }): TypedTrigger<LinearTrigger> {
+        return new LinearInputConfig("{{escape section.id}}", opts?.project?.projectId ?? null, opts?.eventTypes, opts?.team?.teamId ?? null)
+    },
+}

package/src/providers/typescript/modules/notion/notion.tools.hbs

@@ -0,0 +1,20 @@
+{{sectionHeader "Notion resources"}}
+
+{{> resource-class section.databaseClass}}
+
+{{> resource-class section.pageClass}}
+
+{{#if toolFile}}
+{{sectionHeader "Notion tools"}}
+
+{{> tools-slice toolFile}}
+
+{{/if}}
+{{sectionHeader "Notion skill"}}
+
+/** Notion — read and write to the given databases or pages */
+export function notionSkill(opts?: { databases?: NotionDatabase[]; pages?: NotionPage[] }): TypedSkill<{{{section.skillToolType}}}> {
+    return new NotionConfig("{{escape section.id}}",
+        opts?.databases?.map(d => d.databaseId), opts?.databases?.map(d => d.title),
+        opts?.pages?.map(p => p.pageId), opts?.pages?.map(p => p.title))
+}