@pstdio/sdk 0.1.0

package/dist/api/actions.d.ts

@@ -0,0 +1,12 @@
+import type { TargetType } from "../plugins/types";
+export type ExecuteActionInput = {
+    target_type: TargetType;
+    target_id: string;
+};
+export type ActionResult = {
+    status: "success";
+    session_id?: string;
+} | {
+    status: "error";
+    message: string;
+};

package/dist/api/agents.d.ts

@@ -0,0 +1 @@
+export type { SetupAgentInput, SetupAvailableAgentsInput, UpdateAgentInput } from "pstdio-api-contracts";

package/dist/api/index.d.ts

@@ -0,0 +1,9 @@
+export type { ActionResult, ExecuteActionInput } from "./actions";
+export type { SetupAgentInput, SetupAvailableAgentsInput, UpdateAgentInput } from "./agents";
+export type { CreateProjectInput, RegisterRepoInput } from "./projects";
+export type { ApprovalInput, CreateSessionInput, FollowUpInput, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse, } from "./sessions";
+export type { CreateAttemptStatusInput, CreateStatusInput } from "./statuses";
+export type { CreateTagInput, CreateTagOptionInput, UpdateTagInput, UpdateTagOptionInput } from "./tags";
+export type { CreateTemplateInput, UpdateTemplateInput } from "./templates";
+export type { CreateTicketAttemptInput, CreateTicketInput, ListTicketsInput, TicketAttemptMode, TicketAttemptResponse, UpdateTicketInput, UpdateWhenAttemptStatusInput, UpdateWhenAttemptStatusResponse, UploadTicketFileInput, } from "./tickets";
+export type { CreateWorkspaceInput, RemoveWorktreeResponse, UpdateAttemptStatusInput, UpdateAttemptStatusResponse, } from "./workspaces";

package/dist/api/projects.d.ts

@@ -0,0 +1 @@
+export type { CreateProjectInput, RegisterRepoInput } from "pstdio-api-contracts";

package/dist/api/sessions.d.ts

@@ -0,0 +1 @@
+export type { ApprovalInput, CreateSessionInput, FollowUpInput, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse, } from "pstdio-api-contracts";

package/dist/api/statuses.d.ts

@@ -0,0 +1 @@
+export type { CreateAttemptStatusInput, CreateStatusInput } from "pstdio-api-contracts";

package/dist/api/tags.d.ts

@@ -0,0 +1 @@
+export type { CreateTagInput, CreateTagOptionInput, UpdateTagInput, UpdateTagOptionInput, } from "pstdio-api-contracts";

package/dist/api/templates.d.ts

@@ -0,0 +1 @@
+export type { CreateTemplateInput, UpdateTemplateInput } from "pstdio-api-contracts";

package/dist/api/tickets.d.ts

@@ -0,0 +1,23 @@
+export type { CreateTicketAttemptInput, CreateTicketInput, TicketAttemptMode, UpdateTicketInput, UpdateWhenAttemptStatusInput, UpdateWhenAttemptStatusResponse, UploadTicketFileInput, } from "pstdio-api-contracts";
+import type { Ticket, Workspace } from "../resources";
+export type ListTicketsInput = {
+    status?: string;
+    tag?: string | string[];
+    archived?: boolean;
+    draft?: boolean;
+    parent_id?: string;
+    shorthand?: string;
+    search?: string;
+};
+export type TicketAttemptResponse = {
+    mode: "worktree" | "current_branch";
+    ticket: Ticket;
+    workspace: Workspace;
+    session: {
+        id: string;
+        workspace_id: string;
+        title: string;
+        created_at: string;
+        updated_at: string;
+    } | null;
+};

package/dist/api/workspaces.d.ts

@@ -0,0 +1 @@
+export type { CreateWorkspaceInput, RemoveWorktreeResponse, UpdateAttemptStatusInput, UpdateAttemptStatusResponse, } from "pstdio-api-contracts";

package/dist/client/actions.d.ts

@@ -0,0 +1,8 @@
+import type { ActionResult, ExecuteActionInput } from "../api/actions";
+import type { ActionDescriptor, TargetType } from "../plugins/types";
+import type { RequestFn } from "./request";
+export type ActionClient = {
+    list(projectId: string, targetType?: TargetType): Promise<ActionDescriptor[]>;
+    execute(projectId: string, actionKey: string, input: ExecuteActionInput): Promise<ActionResult>;
+};
+export declare const createActionClient: (request: RequestFn) => ActionClient;

package/dist/client/agents.d.ts

@@ -0,0 +1,13 @@
+import type { AgentModel, SetupAgentInput, SetupAvailableAgentsInput, UpdateAgentInput } from "pstdio-api-contracts";
+import type { AgentConfig, AgentInfo } from "../resources";
+import type { RequestFn } from "./request";
+export type AgentClient = {
+    list(): Promise<AgentConfig[]>;
+    info(): Promise<AgentInfo[]>;
+    models(agentId: string): Promise<AgentModel[]>;
+    setup(input: SetupAgentInput): Promise<AgentConfig>;
+    setupAvailable(input: SetupAvailableAgentsInput): Promise<AgentConfig[]>;
+    update(agentId: string, input: UpdateAgentInput): Promise<AgentConfig>;
+    delete(agentId: string): Promise<void>;
+};
+export declare const createAgentClient: (request: RequestFn) => AgentClient;

package/dist/client/client.d.ts

@@ -0,0 +1,24 @@
+import { type ActionClient } from "./actions";
+import { type AgentClient } from "./agents";
+import { type ProjectClient } from "./projects";
+import type { ClientOptions } from "./request";
+import { type SessionClient } from "./sessions";
+import { type SkillClient } from "./skills";
+import { type StatusClient } from "./statuses";
+import { type TagClient } from "./tags";
+import { type TemplateClient } from "./templates";
+import { type TicketClient } from "./tickets";
+import { type WorkspaceClient } from "./workspaces";
+export type PstdioClient = {
+    projects: ProjectClient;
+    tickets: TicketClient;
+    workspaces: WorkspaceClient;
+    sessions: SessionClient;
+    statuses: StatusClient;
+    tags: TagClient;
+    templates: TemplateClient;
+    skills: SkillClient;
+    agents: AgentClient;
+    actions: ActionClient;
+};
+export declare const createClient: (options?: ClientOptions) => PstdioClient;

package/dist/client/index.d.ts

@@ -0,0 +1,12 @@
+export type { ActionClient } from "./actions";
+export type { AgentClient } from "./agents";
+export { createClient, type PstdioClient } from "./client";
+export type { ProjectClient } from "./projects";
+export { type ClientOptions, createRequest, PstdioApiError, type RequestFn } from "./request";
+export type { SessionClient } from "./sessions";
+export type { SkillClient } from "./skills";
+export type { StatusClient } from "./statuses";
+export type { TagClient } from "./tags";
+export type { TemplateClient } from "./templates";
+export type { TicketClient } from "./tickets";
+export type { WorkspaceClient } from "./workspaces";

package/dist/client/index.js

@@ -0,0 +1,215 @@
+// src/client/actions.ts
+var createActionClient = (request) => ({
+  list: (projectId, targetType) => request(targetType ? `/v1/projects/${projectId}/actions?targetType=${targetType}` : `/v1/projects/${projectId}/actions`),
+  execute: (projectId, actionKey, input) => request(`/v1/projects/${projectId}/actions/${encodeURIComponent(actionKey)}/execute`, {
+    method: "POST",
+    body: input
+  })
+});
+
+// src/client/agents.ts
+var createAgentClient = (request) => ({
+  list: () => request("/v1/agents"),
+  info: () => request("/v1/agents/info"),
+  models: (agentId) => request(`/v1/agents/${agentId}/models`),
+  setup: (input) => request("/v1/agents", { method: "POST", body: input }),
+  setupAvailable: (input) => request("/v1/agents/setup-available", { method: "POST", body: input }),
+  update: (agentId, input) => request(`/v1/agents/${agentId}`, { method: "PATCH", body: input }),
+  delete: (agentId) => request(`/v1/agents/${agentId}`, { method: "DELETE" })
+});
+
+// src/client/projects.ts
+var createProjectClient = (request) => ({
+  list: () => request("/v1/projects"),
+  get: (projectId) => request(`/v1/projects/${projectId}`),
+  create: (input) => request("/v1/projects", { method: "POST", body: input }),
+  delete: (projectId) => request(`/v1/projects/${projectId}`, { method: "DELETE" }),
+  listRepos: (projectId) => request(`/v1/projects/${projectId}/repos`),
+  registerRepo: (projectId, input) => request(`/v1/projects/${projectId}/repos`, { method: "POST", body: input }),
+  removeRepo: (projectId, repoId) => request(`/v1/projects/${projectId}/repos/${repoId}`, { method: "DELETE" })
+});
+
+// src/client/request.ts
+class PstdioApiError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "PstdioApiError";
+    this.status = status;
+  }
+}
+var readErrorMessage = (errorBody, status) => {
+  if (errorBody && typeof errorBody === "object" && errorBody !== null && "error" in errorBody) {
+    const message = String(errorBody.error);
+    const hookOutput = "hook_output" in errorBody && typeof errorBody.hook_output === "string" ? errorBody.hook_output.trim() : "";
+    return hookOutput ? `${message}
+${hookOutput}` : message;
+  }
+  return `Request failed: ${status}`;
+};
+var createRequest = (options) => {
+  const baseUrl = options.baseUrl ?? (typeof process !== "undefined" ? process.env.PSTDIO_API_URL : undefined) ?? "http://localhost:19840";
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  return async (path, reqOpts = {}) => {
+    const headers = {};
+    if (reqOpts.body !== undefined)
+      headers["content-type"] = "application/json";
+    if (options.token)
+      headers.authorization = `Bearer ${options.token}`;
+    const response = await fetchFn(`${baseUrl}${path}`, {
+      method: reqOpts.method ?? "GET",
+      headers,
+      body: reqOpts.body !== undefined ? JSON.stringify(reqOpts.body) : undefined,
+      signal: reqOpts.signal
+    });
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => null);
+      const message = readErrorMessage(errorBody, response.status);
+      throw new PstdioApiError(message, response.status);
+    }
+    if (response.status === 204)
+      return;
+    return response.json();
+  };
+};
+
+// src/client/sessions.ts
+var createSessionClient = (request) => ({
+  list: (projectId) => request(`/v1/sessions?project_id=${projectId}`),
+  get: (sessionId) => request(`/v1/sessions/${sessionId}`),
+  create: (input) => request("/v1/sessions", { method: "POST", body: input }),
+  archive: (sessionId) => request(`/v1/sessions/${sessionId}/archive`, { method: "POST" }),
+  followUp: (sessionId, input) => request(`/v1/sessions/${sessionId}/follow-up`, { method: "POST", body: input }),
+  approve: (sessionId, input) => request(`/v1/sessions/${sessionId}/approve`, { method: "POST", body: input }),
+  getConversation: (sessionId) => request(`/v1/sessions/${sessionId}/conversation`),
+  resolveSessionId: (input) => request("/v1/sessions/resolve-session-id", { method: "POST", body: input }),
+  updateStatus: (sessionId, status) => request(`/v1/sessions/${sessionId}/status`, { method: "PATCH", body: { status } })
+});
+
+// src/client/skills.ts
+var createSkillClient = (request) => ({
+  list: (projectId) => request(`/v1/projects/${projectId}/skills`),
+  get: (projectId, skillId) => request(`/v1/projects/${projectId}/skills/${skillId}`),
+  update: (projectId, skillName) => request(`/v1/projects/${projectId}/skills/${skillName}/update`, { method: "POST" })
+});
+
+// src/client/statuses.ts
+var createStatusClient = (request) => ({
+  list: (projectId) => request(`/v1/projects/${projectId}/statuses`),
+  create: (projectId, input) => request(`/v1/projects/${projectId}/statuses`, { method: "POST", body: input }),
+  update: (projectId, statusId, input) => request(`/v1/projects/${projectId}/statuses/${statusId}`, { method: "PATCH", body: input }),
+  setDefault: (projectId, statusId) => request(`/v1/projects/${projectId}/statuses/${statusId}/set-default`, { method: "PATCH" }),
+  delete: (projectId, statusId) => request(`/v1/projects/${projectId}/statuses/${statusId}`, { method: "DELETE" }),
+  listAttemptStatuses: (projectId) => request(`/v1/projects/${projectId}/attempt-statuses`),
+  createAttemptStatus: (projectId, input) => request(`/v1/projects/${projectId}/attempt-statuses`, { method: "POST", body: input }),
+  updateAttemptStatus: (projectId, statusId, input) => request(`/v1/projects/${projectId}/attempt-statuses/${statusId}`, { method: "PATCH", body: input }),
+  deleteAttemptStatus: (projectId, statusId) => request(`/v1/projects/${projectId}/attempt-statuses/${statusId}`, { method: "DELETE" })
+});
+
+// src/client/tags.ts
+var createTagClient = (request) => ({
+  list: (projectId) => request(`/v1/projects/${projectId}/ticket-tags`),
+  create: (projectId, input) => request(`/v1/projects/${projectId}/ticket-tags`, { method: "POST", body: input }),
+  update: (projectId, tagId, input) => request(`/v1/projects/${projectId}/ticket-tags/${tagId}`, { method: "PATCH", body: input }),
+  delete: (projectId, tagId) => request(`/v1/projects/${projectId}/ticket-tags/${tagId}`, { method: "DELETE" }),
+  createOption: (projectId, tagId, input) => request(`/v1/projects/${projectId}/ticket-tags/${tagId}/options`, { method: "POST", body: input }),
+  updateOption: (projectId, tagId, optionId, input) => request(`/v1/projects/${projectId}/ticket-tags/${tagId}/options/${optionId}`, { method: "PATCH", body: input }),
+  deleteOption: (projectId, tagId, optionId) => request(`/v1/projects/${projectId}/ticket-tags/${tagId}/options/${optionId}`, { method: "DELETE" })
+});
+
+// src/client/templates.ts
+var createTemplateClient = (request) => ({
+  list: (projectId) => request(`/v1/projects/${projectId}/templates`),
+  get: (projectId, templateId) => request(`/v1/projects/${projectId}/templates/${templateId}`),
+  create: (projectId, input) => request(`/v1/projects/${projectId}/templates`, { method: "POST", body: input }),
+  update: (projectId, templateId, input) => request(`/v1/projects/${projectId}/templates/${templateId}`, { method: "PUT", body: input }),
+  delete: (projectId, templateId) => request(`/v1/projects/${projectId}/templates/${templateId}`, { method: "DELETE" })
+});
+
+// src/client/tickets.ts
+var resolveBaseUrl = (options) => options.baseUrl ?? (typeof process !== "undefined" ? process.env.PSTDIO_API_URL : undefined) ?? "http://localhost:19840";
+var readErrorMessage2 = async (response) => {
+  const errorBody = await response.json().catch(() => null);
+  if (errorBody && typeof errorBody === "object" && errorBody !== null && "error" in errorBody) {
+    return String(errorBody.error);
+  }
+  return `Request failed: ${response.status}`;
+};
+var buildTicketsQuery = (projectId, input = {}) => {
+  const params = new URLSearchParams({ project_id: projectId });
+  if (input.status)
+    params.append("status", input.status);
+  if (Array.isArray(input.tag)) {
+    for (const tag of input.tag)
+      params.append("tag", tag);
+  } else if (input.tag) {
+    params.append("tag", input.tag);
+  }
+  if (input.archived !== undefined)
+    params.append("archived", String(input.archived));
+  if (input.draft !== undefined)
+    params.append("draft", String(input.draft));
+  if (input.parent_id)
+    params.append("parent_id", input.parent_id);
+  if (input.shorthand)
+    params.append("shorthand", input.shorthand);
+  if (input.search)
+    params.append("search", input.search);
+  return params.toString();
+};
+var createTicketClient = (request, options = {}) => ({
+  list: (projectId, input) => request(`/v1/tickets?${buildTicketsQuery(projectId, input)}`),
+  get: (ticketId) => request(`/v1/tickets/${ticketId}`),
+  create: (input) => request("/v1/tickets", { method: "POST", body: input }),
+  update: (ticketId, input) => request(`/v1/tickets/${ticketId}`, { method: "PATCH", body: input }),
+  delete: (ticketId) => request(`/v1/tickets/${ticketId}`, { method: "DELETE" }),
+  createAttempt: (ticketId, input) => request(`/v1/tickets/${ticketId}/attempts`, { method: "POST", body: input }),
+  updateWhenAttemptStatus: (ticketId, input) => request(`/v1/tickets/${ticketId}/update-when-attempt-status`, { method: "POST", body: input }),
+  listFiles: (ticketId) => request(`/v1/tickets/${ticketId}/files`),
+  getFileContent: async (ticketId, fileId) => {
+    const baseUrl = resolveBaseUrl(options);
+    const fetchFn = options.fetch ?? globalThis.fetch;
+    const headers = {};
+    if (options.token)
+      headers.authorization = `Bearer ${options.token}`;
+    const response = await fetchFn(`${baseUrl}/v1/tickets/${encodeURIComponent(ticketId)}/files/${encodeURIComponent(fileId)}/content`, { headers });
+    if (!response.ok) {
+      throw new PstdioApiError(await readErrorMessage2(response), response.status);
+    }
+    return new Uint8Array(await response.arrayBuffer());
+  },
+  uploadFile: (ticketId, input) => request(`/v1/tickets/${ticketId}/files`, { method: "POST", body: input }),
+  deleteFile: (ticketId, fileId) => request(`/v1/tickets/${ticketId}/files/${fileId}`, { method: "DELETE" })
+});
+
+// src/client/workspaces.ts
+var createWorkspaceClient = (request) => ({
+  list: (projectId) => request(`/v1/workspaces?project_id=${projectId}`),
+  getByShorthand: (projectId, shorthand) => request(`/v1/workspaces/by-shorthand?project_id=${encodeURIComponent(projectId)}&shorthand=${encodeURIComponent(shorthand)}`),
+  create: (input) => request("/v1/workspaces", { method: "POST", body: input }),
+  updateAttemptStatus: (workspaceId, input) => request(`/v1/workspaces/${workspaceId}/attempt-status`, { method: "PATCH", body: input }),
+  removeWorktree: (workspaceId) => request(`/v1/workspaces/${workspaceId}/remove-worktree`, { method: "POST" }),
+  delete: (workspaceId) => request(`/v1/workspaces/${workspaceId}`, { method: "DELETE" })
+});
+
+// src/client/client.ts
+var createClient = (options = {}) => {
+  const request = createRequest(options);
+  return {
+    projects: createProjectClient(request),
+    tickets: createTicketClient(request, options),
+    workspaces: createWorkspaceClient(request),
+    sessions: createSessionClient(request),
+    statuses: createStatusClient(request),
+    tags: createTagClient(request),
+    templates: createTemplateClient(request),
+    skills: createSkillClient(request),
+    agents: createAgentClient(request),
+    actions: createActionClient(request)
+  };
+};
+export {
+  createRequest,
+  createClient,
+  PstdioApiError
+};

package/dist/client/projects.d.ts

@@ -0,0 +1,13 @@
+import type { CreateProjectInput, RegisterRepoInput, Repo } from "pstdio-api-contracts";
+import type { Project } from "../resources";
+import type { RequestFn } from "./request";
+export type ProjectClient = {
+    list(): Promise<Project[]>;
+    get(projectId: string): Promise<Project>;
+    create(input: CreateProjectInput): Promise<Project>;
+    delete(projectId: string): Promise<void>;
+    listRepos(projectId: string): Promise<Repo[]>;
+    registerRepo(projectId: string, input: RegisterRepoInput): Promise<Repo>;
+    removeRepo(projectId: string, repoId: string): Promise<void>;
+};
+export declare const createProjectClient: (request: RequestFn) => ProjectClient;

package/dist/client/request.d.ts

@@ -0,0 +1,16 @@
+export type ClientOptions = {
+    baseUrl?: string;
+    token?: string;
+    fetch?: typeof fetch;
+};
+export declare class PstdioApiError extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}
+export type RequestOptions = {
+    method?: string;
+    body?: unknown;
+    signal?: AbortSignal;
+};
+export type RequestFn = <T>(path: string, options?: RequestOptions) => Promise<T>;
+export declare const createRequest: (options: ClientOptions) => RequestFn;

package/dist/client/sessions.d.ts

@@ -0,0 +1,15 @@
+import type { ApprovalInput, CreateSessionInput, FollowUpInput, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse } from "pstdio-api-contracts";
+import type { Session } from "../resources";
+import type { RequestFn } from "./request";
+export type SessionClient = {
+    list(projectId: string): Promise<Session[]>;
+    get(sessionId: string): Promise<Session>;
+    create(input: CreateSessionInput): Promise<Session>;
+    archive(sessionId: string): Promise<void>;
+    followUp(sessionId: string, input: FollowUpInput): Promise<Session>;
+    approve(sessionId: string, input: ApprovalInput): Promise<void>;
+    getConversation(sessionId: string): Promise<SessionConversationResponse>;
+    resolveSessionId(input: ResolveSessionIdInput): Promise<ResolveSessionIdResponse>;
+    updateStatus(sessionId: string, status: string): Promise<Session>;
+};
+export declare const createSessionClient: (request: RequestFn) => SessionClient;

package/dist/client/skills.d.ts

@@ -0,0 +1,8 @@
+import type { Skill, SkillWithContent } from "../resources";
+import type { RequestFn } from "./request";
+export type SkillClient = {
+    list(projectId: string): Promise<Skill[]>;
+    get(projectId: string, skillId: string): Promise<SkillWithContent>;
+    update(projectId: string, skillName: string): Promise<SkillWithContent>;
+};
+export declare const createSkillClient: (request: RequestFn) => SkillClient;

package/dist/client/statuses.d.ts

@@ -0,0 +1,22 @@
+import type { AttemptStatus, CreateAttemptStatusInput, CreateStatusInput } from "pstdio-api-contracts";
+import type { Status } from "../resources";
+import type { RequestFn } from "./request";
+export type StatusClient = {
+    list(projectId: string): Promise<Status[]>;
+    create(projectId: string, input: CreateStatusInput): Promise<Status>;
+    update(projectId: string, statusId: string, input: {
+        color?: string;
+    }): Promise<Status>;
+    setDefault(projectId: string, statusId: string): Promise<void>;
+    delete(projectId: string, statusId: string): Promise<void>;
+    listAttemptStatuses(projectId: string): Promise<AttemptStatus[]>;
+    createAttemptStatus(projectId: string, input: CreateAttemptStatusInput): Promise<AttemptStatus>;
+    updateAttemptStatus(projectId: string, statusId: string, input: {
+        name?: string;
+        color?: string;
+        sort_order?: number;
+        is_default?: boolean;
+    }): Promise<AttemptStatus>;
+    deleteAttemptStatus(projectId: string, statusId: string): Promise<void>;
+};
+export declare const createStatusClient: (request: RequestFn) => StatusClient;

package/dist/client/tags.d.ts

@@ -0,0 +1,13 @@
+import type { CreateTagInput, CreateTagOptionInput, UpdateTagInput, UpdateTagOptionInput } from "../api/tags";
+import type { Tag, TagOption } from "../resources";
+import type { RequestFn } from "./request";
+export type TagClient = {
+    list(projectId: string): Promise<Tag[]>;
+    create(projectId: string, input: CreateTagInput): Promise<Tag>;
+    update(projectId: string, tagId: string, input: UpdateTagInput): Promise<Tag>;
+    delete(projectId: string, tagId: string): Promise<void>;
+    createOption(projectId: string, tagId: string, input: CreateTagOptionInput): Promise<TagOption>;
+    updateOption(projectId: string, tagId: string, optionId: string, input: UpdateTagOptionInput): Promise<TagOption>;
+    deleteOption(projectId: string, tagId: string, optionId: string): Promise<void>;
+};
+export declare const createTagClient: (request: RequestFn) => TagClient;

package/dist/client/templates.d.ts

@@ -0,0 +1,11 @@
+import type { CreateTemplateInput, UpdateTemplateInput } from "../api/templates";
+import type { Template, TemplateWithContent } from "../resources";
+import type { RequestFn } from "./request";
+export type TemplateClient = {
+    list(projectId: string): Promise<Template[]>;
+    get(projectId: string, templateId: string): Promise<TemplateWithContent>;
+    create(projectId: string, input: CreateTemplateInput): Promise<Template>;
+    update(projectId: string, templateId: string, input: UpdateTemplateInput): Promise<Template>;
+    delete(projectId: string, templateId: string): Promise<void>;
+};
+export declare const createTemplateClient: (request: RequestFn) => TemplateClient;

package/dist/client/tickets.d.ts

@@ -0,0 +1,17 @@
+import type { CreateTicketAttemptInput, CreateTicketInput, ListTicketsInput, TicketAttemptResponse, UpdateTicketInput, UpdateWhenAttemptStatusInput, UpdateWhenAttemptStatusResponse, UploadTicketFileInput } from "../api/tickets";
+import type { Ticket, TicketDetail, TicketFile, TicketListItem } from "../resources";
+import { type ClientOptions, type RequestFn } from "./request";
+export type TicketClient = {
+    list(projectId: string, input?: ListTicketsInput): Promise<TicketListItem[]>;
+    get(ticketId: string): Promise<TicketDetail>;
+    create(input: CreateTicketInput): Promise<Ticket>;
+    update(ticketId: string, input: UpdateTicketInput): Promise<Ticket>;
+    delete(ticketId: string): Promise<void>;
+    createAttempt(ticketId: string, input: CreateTicketAttemptInput): Promise<TicketAttemptResponse>;
+    updateWhenAttemptStatus(ticketId: string, input: UpdateWhenAttemptStatusInput): Promise<UpdateWhenAttemptStatusResponse>;
+    listFiles(ticketId: string): Promise<TicketFile[]>;
+    getFileContent(ticketId: string, fileId: string): Promise<Uint8Array>;
+    uploadFile(ticketId: string, input: UploadTicketFileInput): Promise<TicketFile>;
+    deleteFile(ticketId: string, fileId: string): Promise<void>;
+};
+export declare const createTicketClient: (request: RequestFn, options?: ClientOptions) => TicketClient;

package/dist/client/workspaces.d.ts

@@ -0,0 +1,12 @@
+import type { CreateWorkspaceInput, RemoveWorktreeResponse, UpdateAttemptStatusInput, UpdateAttemptStatusResponse } from "pstdio-api-contracts";
+import type { Workspace, WorkspaceListItem } from "../resources";
+import type { RequestFn } from "./request";
+export type WorkspaceClient = {
+    list(projectId: string): Promise<WorkspaceListItem[]>;
+    getByShorthand(projectId: string, shorthand: string): Promise<Workspace>;
+    create(input: CreateWorkspaceInput): Promise<Workspace>;
+    updateAttemptStatus(workspaceId: string, input: UpdateAttemptStatusInput): Promise<UpdateAttemptStatusResponse>;
+    removeWorktree(workspaceId: string): Promise<RemoveWorktreeResponse>;
+    delete(workspaceId: string): Promise<void>;
+};
+export declare const createWorkspaceClient: (request: RequestFn) => WorkspaceClient;

package/dist/hooks/attempt.d.ts

@@ -0,0 +1,14 @@
+import type { BaseHookContext } from "./base";
+import type { HookTicket, HookWorkspace } from "./entities";
+export type AttemptStatusChangeContext = BaseHookContext & {
+    workspace: HookWorkspace;
+    workspaceId: string;
+    prompts: Record<string, string>;
+    ticket?: HookTicket;
+    worktreePath?: string;
+    branch?: string;
+    fromStatus: string;
+    toStatus: string;
+    sessionId?: string;
+    originalSessionId?: string;
+};

package/dist/hooks/base.d.ts

@@ -0,0 +1,17 @@
+import type { FollowUpInput } from "../api/sessions";
+import type { PstdioClient } from "../client";
+import type { Session } from "../resources";
+export type SessionFollowupInput = Omit<FollowUpInput, "template" | "vars">;
+type HookSessionClient = {
+    followup(input: SessionFollowupInput): Promise<Session>;
+};
+export type HookClient = PstdioClient & {
+    session: HookSessionClient;
+};
+export type HookPayload = Record<string, unknown>;
+export type BaseHookContext = {
+    client: HookClient;
+    projectId: string;
+    payload?: HookPayload;
+};
+export {};

package/dist/hooks/entities.d.ts

@@ -0,0 +1,8 @@
+import type { Ticket, Workspace } from "../resources";
+export type HookTicket = Ticket & {
+    status_name: string | null;
+};
+export type HookWorkspace = Workspace & {
+    ticket_shorthand: string;
+    attempt_status_name: string | null;
+};

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export type { AttemptStatusChangeContext } from "./attempt";
+export type { BaseHookContext, HookClient, HookPayload, SessionFollowupInput } from "./base";
+export type { SessionHookContext } from "./session";
+export type { TicketContext, TicketCreationContext, TicketStatusChangeContext } from "./ticket";
+export type { WorktreeContext, WorktreeCreateContext } from "./worktree";

package/dist/hooks/session.d.ts

@@ -0,0 +1,13 @@
+import type { BaseHookContext } from "./base";
+import type { HookTicket, HookWorkspace } from "./entities";
+export type SessionHookContext = BaseHookContext & {
+    sessionId: string;
+    sessionStatus: "in_progress" | "awaiting_input" | "completed" | "failed" | "cancelled";
+    originalSessionId?: string;
+    workspace?: HookWorkspace;
+    workspaceId?: string;
+    worktreePath?: string;
+    branch?: string;
+    ticket?: HookTicket;
+    attemptStatus?: string;
+};

package/dist/hooks/ticket.d.ts

@@ -0,0 +1,23 @@
+import type { BaseHookContext } from "./base";
+export type TicketContext = BaseHookContext & {
+    id: string;
+    shorthand: string;
+    displayTitle: string | null;
+    userPrompt: string | null;
+    parentId: string | null;
+    draft: boolean;
+    archived: boolean;
+    status: string | null;
+    tagIds: string[];
+    tagNames: string[];
+    fileIds: string[];
+};
+export type TicketCreationContext = Omit<TicketContext, "id" | "shorthand"> & {
+    id: null;
+    shorthand: null;
+    content: string | null;
+};
+export type TicketStatusChangeContext = TicketContext & {
+    fromStatus: string | null;
+    toStatus: string | null;
+};

package/dist/hooks/worktree.d.ts

@@ -0,0 +1,52 @@
+import type { BaseHookContext } from "./base";
+export type WorktreeCreateContext = BaseHookContext & {
+    repoPath: string;
+    worktreePath: string;
+    branch: string;
+    workspace: string;
+    ticket: string;
+    base: string;
+};
+export type WorktreeContext = BaseHookContext & {
+    repoPath: string;
+    worktreePath: string;
+    branch: string;
+    workspace: string;
+    workspaceId: string;
+    ticket: string;
+};
+export type CommitContext = {
+    repoPath: string;
+    worktreePath: string;
+    commitMessage: string;
+    stagePolicy: string;
+    commitSha?: string;
+};
+export type RebaseContext = {
+    repoPath: string;
+    branch: string;
+    target: string;
+};
+export type MergeContext = {
+    repoPath: string;
+    branch: string;
+    target: string;
+    squash: boolean;
+    commitMessage: string | null;
+    commitSha?: string;
+};
+export type ConflictContext = {
+    repoPath: string;
+    branch: string;
+    target: string;
+    operation: "rebase" | "merge";
+};
+export type WorktreeRemoveContext = {
+    repoPath: string;
+    worktreePath: string | null;
+    branch: string;
+    workspace: string;
+    workspaceId: string;
+    ticket: string | null;
+    projectId: string;
+};