terse-cli 0.1.16 → 0.1.17

package/templates/python/codegen/partials/deterministic-tools-section.hbs

@@ -0,0 +1,194 @@
+
+
+# === Deterministic tools ===
+
+{{#if hasAttioTools}}
+_ATTIO_FILTER_ATTRS_BY_OBJECT: dict[str, frozenset[str]] = {
+{{#each attio.objects}}
+{{#if hasAttributes}}
+    {{{apiSlugRepr}}}: {{{attrSlugsFrozensetRepr}}},
+{{/if}}
+{{/each}}
+}
+
+
+def _attio_invalid_filter_error(obj_slug: str, attribute: str | None = None) -> ValueError:
+    message = f"Invalid Attio filter for object {obj_slug!r}"
+    if attribute is not None:
+        message += f" on attribute {attribute!r}"
+    message += ": list shorthand is not supported."
+    if attribute == 'domains':
+        message += ' Use scalar shorthand "useterse.ai" or explicit Attio syntax {"domain": {"$eq": "useterse.ai"}}.'
+    else:
+        message += " Use a scalar shorthand or explicit Attio operator/object syntax instead."
+    return ValueError(message)
+
+
+def _validate_attio_filter_node(
+    obj_slug: str,
+    value: object,
+    *,
+    attr_slugs: frozenset[str],
+    current_attribute: str | None = None,
+) -> None:
+    if isinstance(value, dict):
+        for raw_key, child in value.items():
+            if not isinstance(raw_key, str):
+                raise ValueError(f"Invalid Attio filter for object {obj_slug!r}: filter keys must be strings.")
+            key = raw_key
+            if key in ('$and', '$or'):
+                if not isinstance(child, list):
+                    raise ValueError(f"Invalid Attio filter for object {obj_slug!r}: {key} must be a list.")
+                for item in child:
+                    if not isinstance(item, dict):
+                        raise ValueError(f"Invalid Attio filter for object {obj_slug!r}: {key} entries must be objects.")
+                    _validate_attio_filter_node(obj_slug, item, attr_slugs=attr_slugs)
+                continue
+            if key == '$not':
+                if not isinstance(child, dict):
+                    raise ValueError(f"Invalid Attio filter for object {obj_slug!r}: $not must be an object.")
+                _validate_attio_filter_node(obj_slug, child, attr_slugs=attr_slugs)
+                continue
+            if key == '$in':
+                if not isinstance(child, list):
+                    raise ValueError(f"Invalid Attio filter for object {obj_slug!r}: $in must be a list.")
+                continue
+            if key == 'path':
+                if not isinstance(child, list):
+                    raise ValueError(f"Invalid Attio filter for object {obj_slug!r}: path must be a list.")
+                continue
+            if key == 'constraints':
+                if not isinstance(child, dict):
+                    raise ValueError(f"Invalid Attio filter for object {obj_slug!r}: constraints must be an object.")
+                _validate_attio_filter_node(
+                    obj_slug,
+                    child,
+                    attr_slugs=attr_slugs,
+                    current_attribute=current_attribute,
+                )
+                continue
+
+            attribute: str | None = key if key in attr_slugs else current_attribute
+            if isinstance(child, list):
+                raise _attio_invalid_filter_error(obj_slug, attribute)
+            _validate_attio_filter_node(
+                obj_slug,
+                child,
+                attr_slugs=attr_slugs,
+                current_attribute=attribute,
+            )
+
+
+def _serialize_attio_filter(obj_slug: str, value: object | None) -> str | None:
+    if value is None:
+        return None
+
+    parsed = value
+    if isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"Attio filters for object {obj_slug!r} must be valid JSON objects.") from exc
+
+    if not isinstance(parsed, dict):
+        raise ValueError(f"Attio filters for object {obj_slug!r} must be objects.")
+
+    _validate_attio_filter_node(
+        obj_slug,
+        parsed,
+        attr_slugs=_ATTIO_FILTER_ATTRS_BY_OBJECT.get(obj_slug, frozenset()),
+    )
+    return json.dumps(parsed, separators=(',', ':'), sort_keys=True)
+
+
+def _serialize_attio_records(records: Sequence[object]) -> str:
+    return json.dumps(records, separators=(',', ':'), sort_keys=True)
+
+
+class _AttioTools:
+    def __init__(self, agent: _SdkTerseAgent) -> None:
+        self._agent = agent
+{{#each attio.tools}}
+{{#if (eq name "attio_list_objects")}}{{> attio-list-objects-method tool=this attio=../attio}}{{/if}}
+{{#if (eq name "attio_query_records")}}{{> attio-query-records-method tool=this attio=../attio}}{{/if}}
+{{#if (eq name "attio_upsert_record")}}{{> attio-upsert-record-method tool=this attio=../attio}}{{/if}}
+{{/each}}
+{{/if}}
+{{#if hasSnowflakeTools}}
+
+class _SnowflakeTools:
+    def __init__(self, agent: _SdkTerseAgent) -> None:
+        self._agent = agent
+{{#each snowflake.tools}}
+
+    def {{methodName}}(self, query: str) -> {{outputModel}}:
+        return {{outputModel}}.model_validate(
+            self._agent.execute_tool(
+                {{{nameRepr}}},
+                {'integrationId': {{{../snowflake.instanceIdRepr}}}, 'query': query},
+            )
+        )
+{{/each}}
+{{/if}}
+{{#if hasAnyDeterministicTools}}
+
+class GeneratedTools:
+{{#if hasAttioTools}}
+    attio: _AttioTools
+{{/if}}
+{{#if hasSnowflakeTools}}
+    snowflake: _SnowflakeTools
+{{/if}}
+
+    def __init__(
+        self,
+{{#if hasAttioTools}}
+        attio: _AttioTools | None = None,
+{{/if}}
+{{#if hasSnowflakeTools}}
+        snowflake: _SnowflakeTools | None = None,
+{{/if}}
+    ) -> None:
+{{#if hasAttioTools}}
+        if attio is not None:
+            self.attio = attio
+{{/if}}
+{{#if hasSnowflakeTools}}
+        if snowflake is not None:
+            self.snowflake = snowflake
+{{/if}}
+{{else}}
+
+class GeneratedTools:
+    pass
+{{/if}}
+
+
+class TerseAgent(_SdkTerseAgent):
+    tools: GeneratedTools
+
+
+def create_tools(agent: _SdkTerseAgent) -> GeneratedTools:
+    allowed = {skill.integration_type for skill in agent.skills}
+{{#if hasAnyDeterministicTools}}
+    return GeneratedTools(
+{{#if hasAttioTools}}
+        attio=_AttioTools(agent) if 'attio' in allowed else None,
+{{/if}}
+{{#if hasSnowflakeTools}}
+        snowflake=_SnowflakeTools(agent) if 'snowflake' in allowed else None,
+{{/if}}
+    )
+{{else}}
+    _ = allowed
+    return GeneratedTools()
+{{/if}}
+
+
+def attach_tools(agent: _SdkTerseAgent) -> GeneratedTools:
+    tools = create_tools(agent)
+    agent.attach_tools(tools)
+    return tools
+
+
+__all__ = {{{exportedNamesRepr}}}

package/templates/python/codegen/partials/file-header.hbs

@@ -0,0 +1,32 @@
+"""
+Generated by `terse generate`. Do not edit manually.
+
+Type checking:
+    uv run ty check src/
+"""
+
+from __future__ import annotations
+{{#if typingImportsLine}}
+
+{{typingImportsLine}}
+{{/if}}
+{{#if pydanticImportsLine}}
+
+{{pydanticImportsLine}}
+{{/if}}
+{{#if needsJsonImport}}
+
+import json
+{{/if}}
+
+from terse_sdk import (
+{{#each sdkImports}}
+    {{this}},
+{{/each}}
+)
+
+
+def _compact_dict(**values: object) -> dict[str, object]:
+    """Drop None values while preserving falsey config values like False and []."""
+
+    return {key: value for key, value in values.items() if value is not None}

package/templates/python/codegen/partials/schedule-section.hbs

@@ -0,0 +1,9 @@
+
+
+# === Schedule ===
+
+
+class Schedule:
+    @staticmethod
+    def cron(expression: str) -> TriggerConfig:
+        return TriggerConfig(integration_id='system', integration_type='cron_job', config_type='time_trigger', config=_compact_dict(cronExpression=expression))

package/templates/python/codegen/partials/snowflake-section.hbs

@@ -0,0 +1,26 @@
+{{#if snowflake}}
+
+
+# === Snowflake ===
+
+
+class Snowflake:
+    @staticmethod
+    def skill() -> SkillConfig[{{snowflake.skillToolType}}]:
+        return SkillConfig(integration_id={{{snowflake.instanceIdRepr}}}, integration_type='snowflake', config_type='snowflake_output', config=_compact_dict())
+{{else}}
+
+
+# === Snowflake ===
+
+
+class Snowflake:
+    @staticmethod
+    def skill() -> SkillConfig[str]:
+        return SkillConfig(
+            integration_id='snowflake_placeholder',
+            integration_type='snowflake',
+            config_type='snowflake_output',
+            config=_compact_dict(),
+        )
+{{/if}}

package/templates/python/codegen/partials/tool-name-types.hbs

@@ -0,0 +1,15 @@
+{{#if hasAnyToolNameTypes}}
+
+
+# === Tool name types ===
+
+{{#if attioToolNamesLiteral}}
+AttioToolNames = Literal[{{{attioToolNamesLiteral}}}]
+{{/if}}
+{{#if snowflakeToolNamesLiteral}}
+SnowflakeToolNames = Literal[{{{snowflakeToolNamesLiteral}}}]
+{{/if}}
+{{#if allToolNamesLiteral}}
+AllToolNames = Literal[{{{allToolNamesLiteral}}}]
+{{/if}}
+{{/if}}

package/templates/python/init/.python-version.hbs

@@ -0,0 +1 @@
+3.11

package/templates/python/init/README.md.hbs

@@ -0,0 +1,38 @@
+# {{projectName}}
+
+Project scaffolded by `terse-cli`.
+
+## Prerequisites
+
+- Python `>=3.11`
+- [`uv`](https://docs.astral.sh/uv/getting-started/installation/) for dependency management and local commands
+
+If `terse init` did not install dependencies automatically, install `uv` and run:
+
+```bash
+uv sync
+```
+
+## Quick Start
+
+```bash
+uv sync
+terse test
+terse deploy
+```
+
+Edit `src/main.py` to register jobs with `@app.job(...)`.
+
+## Generated Helpers
+
+The starter scaffold registers `Attio.skill()` and `Snowflake.skill()` by default.
+
+After you connect Attio or Snowflake in Terse, rerun `terse generate` to refresh `src/terse_generated.py` with the real integration IDs and deterministic tool wrappers.
+
+Import helpers like `Attio`, `AttioObject`, `Schedule`, `Snowflake`, and `TerseAgent` from `terse_generated`.
+
+If a job registers `skills=[Snowflake.skill()]`, it can call deterministic wrappers like:
+
+```python
+agent.tools.snowflake.execute_query(query="select 1")
+```

package/templates/python/init/gitignore.hbs

@@ -0,0 +1,3 @@
+.venv
+__pycache__
+.env

package/templates/python/init/pyproject.toml.hbs

@@ -0,0 +1,16 @@
+[project]
+name = "{{projectName}}"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+    "{{sdkDependency}}",
+]
+
+[tool.uv]
+package = false
+
+[dependency-groups]
+dev = ["ty"]
+
+[tool.ty.environment]
+python = ".venv"

package/templates/python/init/src/main.py.hbs

@@ -0,0 +1,21 @@
+from terse_sdk import CronJobInputEvent, SdkAgentStreamEventFinalOutput, Terse
+from terse_generated import Attio, Schedule, Snowflake, TerseAgent
+
+app = Terse()
+
+@app.job(
+    name="{{projectName}}",
+    triggers=[Schedule.cron("0 9 * * 1")],
+    skills=[
+        Attio.skill(),
+        Snowflake.skill(),
+    ],
+)
+def run_job(event: CronJobInputEvent, agent: TerseAgent) -> None:
+    prompt = (
+        "Tell a joke"
+        f"Context: {event.formatted_content}"
+    )
+    for stream_event in agent.run(prompt, event):
+        if isinstance(stream_event, SdkAgentStreamEventFinalOutput):
+            print(stream_event.final_output)

package/templates/typescript/codegen/generated.hbs

@@ -0,0 +1,17 @@
+{{> header}}
+
+{{#if github}}{{> github-section github}}{{/if~}}
+{{#if gmail}}{{> gmail-section gmail}}{{/if~}}
+{{#if slack}}{{> slack-section slack}}{{/if~}}
+{{#if figma}}{{> figma-section figma}}{{/if~}}
+{{#if linear}}{{> linear-section linear}}{{/if~}}
+{{#if atlassian}}{{> atlassian-section atlassian}}{{/if~}}
+{{#if notion}}{{> notion-section notion}}{{/if~}}
+{{#if posthog}}{{> posthog-section posthog}}{{/if~}}
+{{#if datadog}}{{> datadog-section datadog}}{{/if~}}
+{{#if launchdarkly}}{{> launchdarkly-section launchdarkly}}{{/if~}}
+{{#if workos}}{{> workos-section workos}}{{/if~}}
+{{#if attio}}{{> attio-section attio}}{{/if~}}
+{{#if snowflake}}{{> snowflake-section snowflake}}{{/if~}}
+{{#if tools}}{{> tools-section tools}}{{/if}}
+{{> system-section system}}

package/templates/typescript/codegen/partials/atlassian-section.hbs

@@ -0,0 +1,32 @@
+{{sectionHeader "Jira & Confluence"}}
+
+{{> resource-class jiraProjectClass}}
+
+{{> resource-class confluencePageClass}}
+
+export const Jira = {
+    /** Trigger when a Jira issue is created */
+    onIssueCreated(opts?: { project?: JiraProject }): JiraConfig {
+        return new JiraConfig("{{escape id}}", opts?.project?.projectKey, opts?.project?.projectId, [JiraEventType.ISSUE_CREATED])
+    },
+    /** Trigger when a Jira issue is updated */
+    onIssueUpdated(opts?: { project?: JiraProject }): JiraConfig {
+        return new JiraConfig("{{escape id}}", opts?.project?.projectKey, opts?.project?.projectId, [JiraEventType.ISSUE_UPDATED])
+    },
+    /** Trigger on all Jira events */
+    trigger(opts?: { project?: JiraProject; eventTypes?: JiraEventType[] }): JiraConfig {
+        return new JiraConfig("{{escape id}}", opts?.project?.projectKey, opts?.project?.projectId, opts?.eventTypes)
+    },
+    /** Use in `skills[]` */
+    skill(opts?: { project?: JiraProject }): TypedSkill<{{{skillToolType}}}> {
+        return new JiraConfig("{{escape id}}", opts?.project?.projectKey, opts?.project?.projectId) as TypedSkill<{{{skillToolType}}}>
+    },
+}
+
+export const Confluence = {
+    /** Use in `skills[]` */
+    skill(opts: { page: ConfluencePage }): TypedSkill<{{{skillToolType}}}> {
+        return new ConfluenceConfig("{{escape id}}", opts.page.spaceName, opts.page.spaceId, opts.page.pageId, opts.page.title) as TypedSkill<{{{skillToolType}}}>
+    },
+}
+

package/templates/typescript/codegen/partials/attio-section.hbs

@@ -0,0 +1,38 @@
+{{sectionHeader "Attio"}}
+
+export type AttioAttributeDefinition<TSlug extends string = string, TType extends string = string> = {
+    apiSlug: TSlug
+    title?: string
+    type?: TType
+    isRequired?: boolean
+    isUnique?: boolean
+}
+
+export class AttioObject<
+    TSlug extends string = string,
+    TRecordValues extends Record<string, unknown> = Record<string, unknown>,
+    TInputValues extends Record<string, unknown> = TRecordValues
+> {
+    constructor(
+        public readonly apiSlug: TSlug,
+        public readonly name: string,
+        public readonly attributes: readonly AttioAttributeDefinition[] = []
+    ) {}
+
+    declare readonly __recordValues: TRecordValues
+    declare readonly __inputValues: TInputValues
+{{#if objects.length}}
+
+{{#each objects}}
+    static {{staticName}} = new AttioObject<"{{escape apiSlug}}", {{{recordValuesType}}}, {{{inputValuesType}}}>("{{escape apiSlug}}", "{{escape singularNoun}}", {{{attributeSource}}})
+{{/each}}
+{{/if}}
+}
+
+export const Attio = {
+    /** Use in `skills[]` */
+    skill(opts: { object: AttioObject<any> }): TypedSkill<{{{skillToolType}}}> {
+        return new AttioOutputConfig("{{escape id}}", opts.object.apiSlug) as TypedSkill<{{{skillToolType}}}>
+    },
+}
+

package/templates/typescript/codegen/partials/datadog-section.hbs

@@ -0,0 +1,11 @@
+{{sectionHeader "Datadog"}}
+
+{{> resource-class indexClass}}
+
+export const Datadog = {
+    /** Use in `skills[]` */
+    skill(opts?: { indexes?: DatadogIndex[] }): TypedSkill<{{{skillToolType}}}> {
+        return new DatadogConfig("{{escape id}}", opts?.indexes?.map(i => i.name)) as TypedSkill<{{{skillToolType}}}>
+    },
+}
+

package/templates/typescript/codegen/partials/figma-section.hbs

@@ -0,0 +1,13 @@
+{{sectionHeader "Figma"}}
+
+export const Figma = {
+    /** Trigger when a comment is added to a Figma file */
+    onComment(opts: { fileKey: string; fileName: string; teamId: string }): FigmaConfig {
+        return new FigmaConfig("{{escape id}}", opts.fileKey, opts.fileName, opts.teamId, [FigmaEventType.FILE_COMMENT])
+    },
+    /** Trigger on all Figma events */
+    trigger(opts: { fileKey: string; fileName: string; teamId: string; eventTypes?: FigmaEventType[] }): FigmaConfig {
+        return new FigmaConfig("{{escape id}}", opts.fileKey, opts.fileName, opts.teamId, opts.eventTypes)
+    },
+}
+

package/templates/typescript/codegen/partials/github-section.hbs

@@ -0,0 +1,62 @@
+{{sectionHeader "GitHub"}}
+
+export class GithubOwner {
+    constructor(public readonly name: string) {}
+{{#if owners.length}}
+
+{{#each 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 repoGroups.length}}
+
+{{#each repoGroups}}
+    static {{ownerStaticName}} = {
+{{#each repos}}
+        {{staticName}}: new Repos({{id}}, "{{escape name}}", GithubOwner.{{../ownerStaticName}}, "{{escape fullName}}"),
+{{/each}}
+    } as const
+{{/each}}
+{{/if}}
+}
+
+export const GitHub = {
+    /** Trigger on push to a repository */
+    onPush(opts: { repo: Repos }): TypedTrigger<GithubPushInputEvent> {
+        return new GitHubConfig("{{escape id}}", [opts.repo.repositoryId], [GitHubEventType.PUSH]) as TypedTrigger<GithubPushInputEvent>
+    },
+    /** Trigger when a pull request is opened */
+    onPROpened(opts: { repo: Repos }): TypedTrigger<GithubPRInputEvent> {
+        return new GitHubConfig("{{escape id}}", [opts.repo.repositoryId], [GitHubEventType.PR_OPENED]) as TypedTrigger<GithubPRInputEvent>
+    },
+    /** Trigger when a pull request is merged */
+    onPRMerged(opts: { repo: Repos }): TypedTrigger<GithubPRInputEvent> {
+        return new GitHubConfig("{{escape id}}", [opts.repo.repositoryId], [GitHubEventType.PR_MERGED]) as TypedTrigger<GithubPRInputEvent>
+    },
+    /** Trigger when a pull request is closed */
+    onPRClosed(opts: { repo: Repos }): TypedTrigger<GithubPRInputEvent> {
+        return new GitHubConfig("{{escape id}}", [opts.repo.repositoryId], [GitHubEventType.PR_CLOSED]) as TypedTrigger<GithubPRInputEvent>
+    },
+    /** Trigger on any pull request event */
+    onPR(opts: { repo: Repos }): TypedTrigger<GithubPRInputEvent> {
+        return new GitHubConfig("{{escape id}}", [opts.repo.repositoryId], [GitHubEventType.PR_OPENED, GitHubEventType.PR_MERGED, GitHubEventType.PR_CLOSED, GitHubEventType.PR_SYNCHRONIZE]) as TypedTrigger<GithubPRInputEvent>
+    },
+    /** Trigger on specific GitHub events for the given repositories */
+    trigger(opts: { repos: Repos[]; eventTypes?: GitHubEventType[] }): TypedTrigger<GithubInputEvent> {
+        return new GitHubConfig("{{escape id}}", opts.repos.map(r => r.repositoryId), opts.eventTypes) as TypedTrigger<GithubInputEvent>
+    },
+    /** Use in `skills[]` */
+    skill(opts: { repos: Repos[] }): TypedSkill<{{{skillToolType}}}> {
+        return new GitHubConfig("{{escape id}}", opts.repos.map(r => r.repositoryId)) as TypedSkill<{{{skillToolType}}}>
+    },
+}
+

package/templates/typescript/codegen/partials/gmail-section.hbs

@@ -0,0 +1,21 @@
+{{sectionHeader "Gmail"}}
+
+export const Gmail = {
+    /** Trigger when a new email is received */
+    onEmail(): GmailConfig {
+        return new GmailConfig("{{escape id}}", [GmailEventType.EMAIL_RECEIVED])
+    },
+    /** Trigger on all Gmail events */
+    trigger(opts?: { eventTypes?: GmailEventType[] }): GmailConfig {
+        return new GmailConfig("{{escape id}}", opts?.eventTypes)
+    },
+    /** Use in `skills[]` */
+    skill(): TypedSkill<{{{skillToolType}}}> {
+        return new GmailOutputConfig("{{escape id}}") as TypedSkill<{{{skillToolType}}}>
+    },
+    /** Use in `skills[]` — creates draft emails */
+    draftSkill(): TypedSkill<{{{skillToolType}}}> {
+        return new GmailDraftOutputConfig("{{escape id}}") as TypedSkill<{{{skillToolType}}}>
+    },
+}
+

package/templates/typescript/codegen/partials/header.hbs

@@ -0,0 +1,12 @@
+// Auto-generated by `terse generate` — do not edit manually
+// Re-run `terse generate` to update.
+
+{{#if useMultilineImports}}
+import {
+{{#each imports}}
+    {{this}},
+{{/each}}
+} from "terse-sdk"
+{{else}}
+import { {{#each imports}}{{this}}{{#unless @last}}, {{/unless}}{{/each}} } from "terse-sdk"
+{{/if}}

package/templates/typescript/codegen/partials/launchdarkly-section.hbs

@@ -0,0 +1,11 @@
+{{sectionHeader "LaunchDarkly"}}
+
+{{> resource-class projectClass}}
+
+export const LaunchDarkly = {
+    /** Use in `skills[]` */
+    skill(opts: { project: LaunchDarklyProject; environmentKeys: string[] }): TypedSkill<{{{skillToolType}}}> {
+        return new LaunchDarklyConfig("{{escape id}}", opts.project.projectKey, opts.environmentKeys) as TypedSkill<{{{skillToolType}}}>
+    },
+}
+

package/templates/typescript/codegen/partials/linear-section.hbs

@@ -0,0 +1,27 @@
+{{sectionHeader "Linear"}}
+
+{{> resource-class teamClass}}
+
+export const Linear = {
+    /** Trigger when a new issue is created */
+    onIssueCreated(opts?: { projectId?: string; projectName?: string }): LinearInputConfig {
+        return new LinearInputConfig("{{escape id}}", opts?.projectId, opts?.projectName, [LinearEventType.ISSUE_CREATED])
+    },
+    /** Trigger when an issue is updated */
+    onIssueUpdated(opts?: { projectId?: string; projectName?: string }): LinearInputConfig {
+        return new LinearInputConfig("{{escape id}}", opts?.projectId, opts?.projectName, [LinearEventType.ISSUE_UPDATED])
+    },
+    /** Trigger when a comment is added to an issue */
+    onComment(opts?: { projectId?: string; projectName?: string }): LinearInputConfig {
+        return new LinearInputConfig("{{escape id}}", opts?.projectId, opts?.projectName, [LinearEventType.COMMENT_CREATED])
+    },
+    /** Trigger on all Linear events */
+    trigger(opts?: { projectId?: string; projectName?: string; eventTypes?: LinearEventType[] }): LinearInputConfig {
+        return new LinearInputConfig("{{escape id}}", opts?.projectId, opts?.projectName, opts?.eventTypes)
+    },
+    /** Use in `skills[]` */
+    skill(opts?: { team?: LinearTeam; projectId?: string; projectName?: string }): TypedSkill<{{{skillToolType}}}> {
+        return new LinearOutputConfig("{{escape id}}", opts?.team?.teamId, opts?.team?.name, opts?.projectId, opts?.projectName) as TypedSkill<{{{skillToolType}}}>
+    },
+}
+

package/templates/typescript/codegen/partials/notion-section.hbs

@@ -0,0 +1,15 @@
+{{sectionHeader "Notion"}}
+
+{{> resource-class databaseClass}}
+
+{{> resource-class pageClass}}
+
+export const Notion = {
+    /** Use in `skills[]` */
+    skill(opts?: { databases?: NotionDatabase[]; pages?: NotionPage[] }): TypedSkill<{{{skillToolType}}}> {
+        return new NotionConfig("{{escape 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)) as TypedSkill<{{{skillToolType}}}>
+    },
+}
+

package/templates/typescript/codegen/partials/posthog-section.hbs

@@ -0,0 +1,11 @@
+{{sectionHeader "PostHog"}}
+
+{{> resource-class projectClass}}
+
+export const Posthog = {
+    /** Use in `skills[]` */
+    skill(opts: { project: PosthogProject }): TypedSkill<{{{skillToolType}}}> {
+        return new PosthogConfig("{{escape id}}", opts.project.projectId, opts.project.name) as TypedSkill<{{{skillToolType}}}>
+    },
+}
+

package/templates/typescript/codegen/partials/resource-class.hbs

@@ -0,0 +1,9 @@
+export class {{className}} {
+    constructor({{{constructorParams}}}) {}
+{{#if items.length}}
+
+{{#each items}}
+    static {{staticName}} = new {{../className}}({{{argsText}}})
+{{/each}}
+{{/if}}
+}