Generated SDK

export class SlackChannel {
    constructor(
        public readonly channelId: string,
        public readonly name: string
    ) {}

    static DealDesk = new SlackChannel("C08XYZ1234", "deal-desk")
    static Engineering = new SlackChannel("C09ABC5678", "engineering")
    static AllTerseInc = new SlackChannel("C01DEF9012", "all-terse-inc")
}

export class SlackUser {
    constructor(
        public readonly userId: string,
        public readonly name: string
    ) {}

    static OnCall = new SlackUser("U08XYZ1234", "on-call")
}

export class GithubOwner {
    constructor(public readonly name: string) {}

    static TerseAI = new GithubOwner("terse-ai")
}

export class Repos {
    constructor(
        public readonly repositoryId: number,
        public readonly name: string,
        public readonly owner: GithubOwner,
        public readonly fullName: string
    ) {}

    static TerseAI = {
        Terse: new Repos(829471023, "terse", GithubOwner.TerseAI, "terse-ai/terse"),
        Docs: new Repos(829471108, "docs", GithubOwner.TerseAI, "terse-ai/docs")
    } as const
}

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 objectId: string,
        public readonly attributes: readonly AttioAttributeDefinition[] = []
    ) {}

    declare readonly __recordValues: TRecordValues
    declare readonly __inputValues: TInputValues

    static Deal = new AttioObject<"deals", { name?: string; stage?: string; amount?: number }, { name?: string; stage?: string; amount?: number }>("deals", "deal", "obj_f1e3c0b2…", [
        /* attributes */
    ])
    static Company = new AttioObject<"companies", { name?: string; domains?: string[] }, { name?: string; domains?: string[] }>("companies", "company", "obj_8d22a17c…", [
        /* attributes */
    ])
}

export const Triggers = {
    slack: {
        /** Trigger on any message in a channel */
        onMessage(opts: { channel: SlackChannel; userIds?: string[] }): TypedTrigger<SlackMessageTrigger> {
            /* … */
        },
        /** Trigger when the Slack app is directly mentioned */
        onAppMention(opts: { channel: SlackChannel }): TypedTrigger<SlackAppMentionTrigger> {
            /* … */
        }
    },
    github: {
        /** Trigger when an issue is created */
        onIssueCreated(opts: { repo: Repos }): TypedTrigger<GithubIssueCreatedTrigger> {
            /* … */
        },
        /** Trigger when a pull request is opened */
        onPROpened(opts: { repo: Repos }): TypedTrigger<GithubPROpenedTrigger> {
            /* … */
        },
        /** Trigger when a pull request is merged */
        onPRMerged(opts: { repo: Repos }): TypedTrigger<GithubPRMergedTrigger> {
            /* … */
        }
    },
    attio: {
        /** Trigger when a record is created. Pass `object` to scope to a specific Attio object. */
        onRecordCreated<T extends GeneratedAttioObject>(opts?: { object: T }): TypedTrigger<AttioRecordCreatedTrigger> {
            /* … */
        }
    },
    schedule: {
        /** Run on a cron schedule (5-field cron expression, evaluated as wall-clock time in `timezone` — an IANA name like "America/New_York", DST-aware — defaulting to UTC) */
        cron(opts: { expression: string; timezone?: Timezone }): TypedTrigger<CronTrigger> {
            /* … */
        }
    }
}

import { createJob, slack, step, waitForInput } from "terse-sdk"
import { $ } from "zx"

import { Repos, SlackChannel, Triggers } from "./terse.generated"

createJob({
    name: "Fix GitHub issue with a durable coding agent",
    triggers: [Triggers.github.onIssueCreated({ repo: Repos.TerseAI.Terse })],
    durable: true,
    onTrigger: async event => {
        const githubUrl = `https://github.com/${event.repository.owner}/${event.repository.name}.git`

        await step($`git clone ${githubUrl} ${repoDir}`)

        const decision = await waitForInput({
            via: slack({ channel: SlackChannel.AllTerseInc.channelId }),
            prompt: "Should I make a PR for this issue?",
            options: [
                { id: "make_pr", label: "Make PR" },
                { id: "stop", label: "Stop" }
            ]
        })
        if (decision.choice === "stop") return
    }
})