@pstdio/sdk 0.1.0

package/dist/plugins/index.js

@@ -0,0 +1,464 @@
+// src/prompts/render-prompt.ts
+import Mustache from "mustache";
+var renderPrompt = (template, data) => Mustache.render(template, data);
+// src/plugins/define-plugin.ts
+var assertActionTriggers = (plugin) => {
+  for (const action of plugin.actions ?? []) {
+    if (typeof action.trigger !== "function") {
+      throw new Error(`Action "${action.key}" is missing trigger(ctx)`);
+    }
+  }
+};
+var definePlugin = (plugin) => {
+  assertActionTriggers(plugin);
+  return plugin;
+};
+// src/plugins/helpers/context.ts
+var firstMatch = (values, ref, readName) => {
+  if (ref) {
+    const byIdMatch = values.find((value) => value.id === ref);
+    if (byIdMatch)
+      return byIdMatch;
+    return values.find((value) => readName(value) === ref) ?? null;
+  }
+  return null;
+};
+var readTicketLike = (value) => {
+  if (!value || typeof value !== "object")
+    return null;
+  const ticket = value;
+  if (typeof ticket.id !== "string" || typeof ticket.shorthand !== "string") {
+    return null;
+  }
+  return ticket;
+};
+var readWorkspaceLike = (value) => {
+  if (!value || typeof value !== "object")
+    return null;
+  const workspace = value;
+  if (typeof workspace.id !== "string" || typeof workspace.workspace_shorthand !== "string") {
+    return null;
+  }
+  return workspace;
+};
+var matchesRef = (ref, id, name) => !ref || ref === id || ref === name;
+var readTicketFromContext = (ctx, ref) => {
+  const actionTarget = "targetType" in ctx && ctx.targetType === "ticket" ? readTicketLike(ctx.target) : null;
+  if (actionTarget && matchesRef(ref, actionTarget.id, actionTarget.shorthand)) {
+    return actionTarget;
+  }
+  const hookTicket = readTicketLike(ctx.ticket);
+  if (hookTicket && matchesRef(ref, hookTicket.id, hookTicket.shorthand)) {
+    return hookTicket;
+  }
+  return null;
+};
+var readWorkspaceFromContext = (ctx, ref) => {
+  const actionTarget = "targetType" in ctx && ctx.targetType === "workspace" ? readWorkspaceLike(ctx.target) : null;
+  if (actionTarget && matchesRef(ref, actionTarget.id, actionTarget.workspace_shorthand)) {
+    return actionTarget;
+  }
+  const hookWorkspace = readWorkspaceLike(ctx.workspace);
+  if (hookWorkspace && matchesRef(ref, hookWorkspace.id, hookWorkspace.workspace_shorthand)) {
+    return hookWorkspace;
+  }
+  return null;
+};
+var resolveSessionIdFromContext = (ctx) => {
+  const actionTarget = "targetType" in ctx && ctx.targetType === "session" ? ctx.target.id : null;
+  if (actionTarget)
+    return actionTarget;
+  const originalSessionId = ctx.originalSessionId;
+  if (typeof originalSessionId === "string" && originalSessionId.length > 0) {
+    return originalSessionId;
+  }
+  const sessionId = ctx.sessionId;
+  if (typeof sessionId === "string" && sessionId.length > 0) {
+    return sessionId;
+  }
+  return null;
+};
+
+// src/plugins/helpers/find-ticket-by-ref.ts
+var findTicketByRef = async (ctx, input) => {
+  const contextualTicket = readTicketFromContext(ctx, input.ticketId);
+  if (contextualTicket)
+    return contextualTicket;
+  const tickets = await ctx.client.tickets.list(ctx.projectId);
+  return firstMatch(tickets, input.ticketId, (ticket) => ticket.shorthand);
+};
+var resolveTicketShorthand = async (ctx, input) => {
+  if (!input.ticketId)
+    return null;
+  const ticket = await findTicketByRef(ctx, input);
+  return ticket?.shorthand ?? null;
+};
+
+// src/plugins/helpers/create-attempt.ts
+var createAttempt = async (ctx, input) => {
+  const ticketId = (await findTicketByRef(ctx, input))?.id;
+  if (!ticketId)
+    return null;
+  const { ticketId: _ticketId, ...attemptInput } = input;
+  return ctx.client.tickets.createAttempt(ticketId, {
+    ...attemptInput,
+    start_session: true
+  });
+};
+// src/plugins/helpers/create-session.ts
+var createSession = async (ctx, input) => ctx.client.sessions.create({
+  project_id: ctx.projectId,
+  ...input
+});
+// src/plugins/helpers/create-workspace.ts
+var createWorkspace = async (ctx, input) => {
+  const ticketId = (await findTicketByRef(ctx, input))?.id;
+  if (!ticketId)
+    return null;
+  const { ticketId: _ticketId, ...attemptInput } = input;
+  return ctx.client.tickets.createAttempt(ticketId, {
+    ...attemptInput,
+    start_session: false
+  });
+};
+// src/plugins/helpers/find-workspace-by-ref.ts
+var findWorkspaceByRef = async (ctx, input) => {
+  const contextualWorkspace = readWorkspaceFromContext(ctx, input.workspaceId);
+  if (contextualWorkspace)
+    return contextualWorkspace;
+  const workspaces = await ctx.client.workspaces.list(ctx.projectId);
+  return firstMatch(workspaces, input.workspaceId, (workspace) => workspace.workspace_shorthand);
+};
+// src/plugins/helpers/followup-session.ts
+var followupSession = async (ctx, input) => {
+  const sessionId = input.sessionId ?? resolveSessionIdFromContext(ctx);
+  if (!sessionId) {
+    throw new Error("followupSession requires sessionId or hook/action session context");
+  }
+  const { sessionId: _sessionId, ...followupInput } = input;
+  return ctx.client.sessions.followUp(sessionId, followupInput);
+};
+// src/plugins/helpers/workspaces-for-ticket.ts
+var workspacesForTicket = async (ctx, input) => {
+  const ticketShorthand = await resolveTicketShorthand(ctx, input);
+  if (!ticketShorthand)
+    return [];
+  const workspaces = await ctx.client.workspaces.list(ctx.projectId);
+  return workspaces.filter((workspace) => workspace.ticket_shorthand === ticketShorthand);
+};
+
+// src/plugins/helpers/get-attempts-for-ticket.ts
+var getAttemptsForTicket = async (ctx, input) => {
+  return workspacesForTicket(ctx, input);
+};
+// src/plugins/helpers/remove-all-worktrees-for-ticket.ts
+var removeAllWorktreesForTicket = async (ctx, input) => {
+  const ticketShorthand = await resolveTicketShorthand(ctx, input);
+  if (!ticketShorthand)
+    return 0;
+  const workspaces = await ctx.client.workspaces.list(ctx.projectId);
+  const ticketWorkspaces = workspaces.filter((workspace) => workspace.ticket_shorthand === ticketShorthand && workspace.worktree_path);
+  let removed = 0;
+  for (const workspace of ticketWorkspaces) {
+    try {
+      const result = await ctx.client.workspaces.removeWorktree(workspace.id);
+      if (result.removed) {
+        removed++;
+      }
+    } catch {}
+  }
+  return removed;
+};
+// src/plugins/helpers/run-command.ts
+import { spawn as nodeSpawn } from "node:child_process";
+var runCommand = async (cwd, command, options = {}) => {
+  const [cmd, ...args] = command;
+  const stdio = options.quiet ? "ignore" : "pipe";
+  return new Promise((resolve) => {
+    const proc = nodeSpawn(cmd, args, { cwd, stdio: ["ignore", stdio, stdio] });
+    const stdout = [];
+    const stderr = [];
+    proc.stdout?.on("data", (chunk) => stdout.push(chunk.toString()));
+    proc.stderr?.on("data", (chunk) => stderr.push(chunk.toString()));
+    proc.on("close", (code) => {
+      resolve({
+        exitCode: code ?? 1,
+        stdout: stdout.join("").trim(),
+        stderr: stderr.join("").trim()
+      });
+    });
+  });
+};
+// src/plugins/helpers/set-ticket-status.ts
+var setTicketStatus = async (ctx, input) => {
+  const [ticket, statuses] = await Promise.all([
+    findTicketByRef(ctx, { ticketId: input.ticket }),
+    ctx.client.statuses.list(ctx.projectId)
+  ]);
+  if (!ticket)
+    return false;
+  const status = statuses.find((candidate) => candidate.name === input.status);
+  if (!status)
+    return false;
+  await ctx.client.tickets.update(ticket.id, { status_id: status.id });
+  return true;
+};
+// src/plugins/helpers/set-workspace-attempt-status.ts
+var setWorkspaceAttemptStatus = async (ctx, input) => {
+  const workspace = await findWorkspaceByRef(ctx, input);
+  const workspaceId = workspace?.id;
+  if (!workspaceId)
+    return false;
+  await ctx.client.workspaces.updateAttemptStatus(workspaceId, {
+    status: input.statusName,
+    session_id: input.sessionId
+  });
+  return true;
+};
+// src/plugins/helpers/ticket-pull.ts
+import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+var TICKETS_DIR = join(".pstdio", "tickets");
+var TICKET_FILES_DIR = "files";
+var escapeYamlScalar = (value) => value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
+var buildTicketFrontmatter = (fields) => {
+  const lines = ["---"];
+  const q = (value) => `"${escapeYamlScalar(value)}"`;
+  lines.push(`ticket_id: ${q(fields.shorthand)}`);
+  if (fields.user_prompt)
+    lines.push(`user_prompt: ${q(fields.user_prompt)}`);
+  lines.push(`created: ${q(fields.created_at)}`);
+  if (fields.draft !== null)
+    lines.push(`draft: ${fields.draft}`);
+  if (fields.status_name)
+    lines.push(`status: ${q(fields.status_name)}`);
+  if (fields.parent_id)
+    lines.push(`parent_id: ${q(fields.parent_id)}`);
+  if (fields.depends_on)
+    lines.push(`depends_on: ${q(fields.depends_on)}`);
+  if (fields.parallelizable)
+    lines.push(`parallelizable: ${q(fields.parallelizable)}`);
+  if (fields.blocked_reason)
+    lines.push(`blocked_reason: ${q(fields.blocked_reason)}`);
+  if (fields.tag_names.length > 0)
+    lines.push(`tags: [${fields.tag_names.map(q).join(", ")}]`);
+  lines.push("---");
+  return lines.join(`
+`);
+};
+var stripFrontmatter = (content) => {
+  if (!content.startsWith("---"))
+    return content;
+  const closingIndex = content.indexOf("---", 3);
+  if (closingIndex === -1)
+    return content;
+  return content.slice(closingIndex + 3);
+};
+var applyFrontmatter = (frontmatter, content) => {
+  const body = stripFrontmatter(content).replace(/^\n+/, "");
+  if (!body)
+    return frontmatter;
+  return `${frontmatter}
+
+${body}`;
+};
+var toRelativeFilePath = (baseDir, absolutePath) => relative(baseDir, absolutePath).split("\\").join("/");
+var resolveTicketDir = (rootPath, shorthand) => {
+  const exactDir = join(rootPath, TICKETS_DIR, shorthand);
+  if (!existsSync(exactDir))
+    return null;
+  if (!statSync(exactDir).isDirectory()) {
+    throw new Error(`Invalid ticket path for ${shorthand}: .pstdio/tickets/${shorthand} is not a directory.`);
+  }
+  return exactDir;
+};
+var writeTicketFile = (rootPath, shorthand, content, overwrite = true) => {
+  const existingDir = resolveTicketDir(rootPath, shorthand);
+  const dir = existingDir ?? join(rootPath, TICKETS_DIR, shorthand);
+  const filePath = join(dir, "ticket.md");
+  if (!overwrite && existsSync(filePath)) {
+    throw new Error(`Local file already exists: ${toRelativeFilePath(rootPath, filePath)}. Use force to overwrite.`);
+  }
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, content);
+  return filePath;
+};
+var resolveTicketAttachmentPath = (rootPath, shorthand, fileName) => {
+  const ticketDir = resolveTicketDir(rootPath, shorthand);
+  if (!ticketDir)
+    throw new Error(`Ticket directory not found for ${shorthand}`);
+  const filesDir = join(ticketDir, TICKET_FILES_DIR);
+  const targetPath = resolve(filesDir, fileName);
+  const rel = relative(filesDir, targetPath);
+  if (isAbsolute(rel) || rel.startsWith("..")) {
+    throw new Error(`Ticket file path resolves outside ticket files directory: ${fileName}`);
+  }
+  return targetPath;
+};
+var writeTicketAttachment = (rootPath, shorthand, fileName, content, overwrite = false) => {
+  const filePath = resolveTicketAttachmentPath(rootPath, shorthand, fileName);
+  if (!overwrite && existsSync(filePath)) {
+    throw new Error(`Local file already exists: ${toRelativeFilePath(rootPath, filePath)}. Use force to overwrite.`);
+  }
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, content);
+  return filePath;
+};
+var isNotFoundError = (error) => typeof error === "object" && error !== null && ("status" in error) && error.status === 404;
+var isTicketShorthand = (value) => /^[A-Za-z]+-\d+$/.test(value);
+var resolveParentFrontmatterValue = async (ctx, parentId) => {
+  if (!parentId)
+    return null;
+  if (isTicketShorthand(parentId))
+    return parentId;
+  try {
+    const parentTicket = await ctx.client.tickets.get(parentId);
+    return parentTicket.shorthand || parentId;
+  } catch (error) {
+    if (isNotFoundError(error))
+      return parentId;
+    throw error;
+  }
+};
+var resolveTicketByShorthand = async (ctx, ticketShorthand) => {
+  const published = await ctx.client.tickets.list(ctx.projectId, { shorthand: ticketShorthand });
+  if (published.length > 0)
+    return published[0];
+  const drafts = await ctx.client.tickets.list(ctx.projectId, { shorthand: ticketShorthand, draft: true });
+  return drafts[0];
+};
+var resolveTicketById = async (ctx, ticketId) => {
+  try {
+    const detail = await ctx.client.tickets.get(ticketId);
+    const byShorthand = await resolveTicketByShorthand(ctx, detail.shorthand);
+    if (byShorthand)
+      return byShorthand;
+    return {
+      ...detail,
+      status_name: null,
+      tag_ids: [],
+      tag_names: []
+    };
+  } catch (error) {
+    if (isNotFoundError(error))
+      return null;
+    throw error;
+  }
+};
+var resolveTicketByRef = async (ctx, ticketId) => {
+  const byId = await resolveTicketById(ctx, ticketId);
+  if (byId)
+    return byId;
+  return resolveTicketByShorthand(ctx, ticketId);
+};
+var pullSingleTicket = async (ctx, rootPath, ticketListItem, force, log) => {
+  const ticket = await ctx.client.tickets.get(ticketListItem.id);
+  const parentId = await resolveParentFrontmatterValue(ctx, ticket.parent_id);
+  const frontmatter = buildTicketFrontmatter({
+    shorthand: ticketListItem.shorthand,
+    created_at: ticket.created_at,
+    draft: ticket.draft,
+    status_name: ticketListItem.status_name,
+    parent_id: parentId,
+    user_prompt: ticket.user_prompt ?? null,
+    depends_on: ticket.depends_on,
+    parallelizable: ticket.parallelizable,
+    blocked_reason: ticket.blocked_reason,
+    tag_names: ticketListItem.tag_names ?? []
+  });
+  const content = applyFrontmatter(frontmatter, ticket.content ?? "");
+  const filePath = writeTicketFile(rootPath, ticketListItem.shorthand, content, force);
+  const ticketDir = filePath.replace(/\/ticket\.md$/, "").replace(`${rootPath}/`, "");
+  const files = await ctx.client.tickets.listFiles(ticket.id);
+  const attachments = files.filter((file) => file.id !== ticket.file_id);
+  for (const file of attachments) {
+    const fileContent = await ctx.client.tickets.getFileContent(ticket.id, file.id);
+    writeTicketAttachment(rootPath, ticketListItem.shorthand, file.file_name, fileContent, force);
+  }
+  log(`Pulled ticket ${ticketListItem.shorthand} to ${ticketDir}`);
+  if (attachments.length > 0)
+    log(`Downloaded ${attachments.length} ticket files`);
+  return { shorthand: ticketListItem.shorthand, downloadedFileCount: attachments.length };
+};
+var pullTickets = async (ctx, input) => {
+  const force = input.force ?? false;
+  const log = input.log ?? (() => {});
+  if (input.ticketId) {
+    const ticket = await resolveTicketByRef(ctx, input.ticketId);
+    if (!ticket)
+      throw new Error(`Ticket not found: ${input.ticketId}`);
+    const result = await pullSingleTicket(ctx, input.rootPath, ticket, force, log);
+    return { pulledTicketShorthands: [result.shorthand], downloadedFileCount: result.downloadedFileCount };
+  }
+  const listedTickets = await ctx.client.tickets.list(ctx.projectId, { archived: false });
+  const tickets = listedTickets.filter((ticket) => !ticket.archived);
+  if (tickets.length === 0) {
+    log("No tickets to pull.");
+    return { pulledTicketShorthands: [], downloadedFileCount: 0 };
+  }
+  const pulledTicketShorthands = [];
+  let downloadedFileCount = 0;
+  for (const ticket of tickets) {
+    const result = await pullSingleTicket(ctx, input.rootPath, ticket, force, log);
+    pulledTicketShorthands.push(result.shorthand);
+    downloadedFileCount += result.downloadedFileCount;
+  }
+  log(`Pulled ${tickets.length} tickets`);
+  return { pulledTicketShorthands, downloadedFileCount };
+};
+// src/plugins/helpers/update-ticket-when-all-attempts-match.ts
+var updateTicketWhenAllAttemptsMatch = async (ctx, input) => {
+  const ticket = await findTicketByRef(ctx, input);
+  const ticketId = ticket?.id;
+  if (!ticketId)
+    return false;
+  const result = await ctx.client.tickets.updateWhenAttemptStatus(ticketId, {
+    all_attempts_status: input.allAttemptsStatus,
+    set_status: input.setStatus
+  });
+  return result.updated;
+};
+// src/plugins/helpers/worktree-bootstrap.ts
+import { cpSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var AGENT_DIRS = [".claude", ".opencode", ".agents"];
+var bootstrapWorktree = async (ctx, input) => {
+  const { repoPath, worktreePath, ticketId } = input;
+  const repoConfig = join2(repoPath, ".pstdio", "config.json");
+  const worktreeConfigDir = join2(worktreePath, ".pstdio");
+  const worktreeConfig = join2(worktreeConfigDir, "config.json");
+  if (existsSync2(repoConfig)) {
+    mkdirSync2(worktreeConfigDir, { recursive: true });
+    cpSync(repoConfig, worktreeConfig);
+  }
+  for (const agentDir of AGENT_DIRS) {
+    const fromDir = join2(repoPath, agentDir);
+    const toDir = join2(worktreePath, agentDir);
+    if (!existsSync2(fromDir))
+      continue;
+    mkdirSync2(toDir, { recursive: true });
+    cpSync(fromDir, toDir, { recursive: true });
+  }
+  if (!ticketId)
+    return;
+  await pullTickets(ctx, { rootPath: worktreePath, ticketId });
+};
+export {
+  workspacesForTicket,
+  updateTicketWhenAllAttemptsMatch,
+  setWorkspaceAttemptStatus,
+  setTicketStatus,
+  runCommand,
+  renderPrompt,
+  removeAllWorktreesForTicket,
+  pullTickets,
+  getAttemptsForTicket,
+  followupSession,
+  findWorkspaceByRef,
+  findTicketByRef,
+  definePlugin,
+  createWorkspace,
+  createSession,
+  createAttempt,
+  bootstrapWorktree
+};

package/dist/plugins/types.d.ts

@@ -0,0 +1,89 @@
+import type { PstdioClient } from "../client/client";
+import type { Session } from "../resources/session";
+import type { TicketListItem } from "../resources/ticket";
+import type { WorkspaceListItem } from "../resources/workspace";
+import type { PluginHooks } from "./hooks";
+export type TargetType = "ticket" | "workspace" | "session";
+export type ActionPlacement = "primary" | "secondary" | "overflow";
+type ActionParamBase = {
+    key: string;
+    label: string;
+    description?: string;
+    required?: boolean;
+    defaultValue?: string;
+};
+export type TextActionParam = ActionParamBase & {
+    type: "text";
+};
+export type LongTextActionParam = ActionParamBase & {
+    type: "longtext";
+};
+export type SelectActionParam = ActionParamBase & {
+    type: "select";
+    options: {
+        value: string;
+        label: string;
+    }[];
+};
+export type TemplateSelectActionParam = ActionParamBase & {
+    type: "template-select";
+    templateType: string;
+};
+export type AgentActionParam = ActionParamBase & {
+    type: "agent";
+};
+export type RepoActionParam = ActionParamBase & {
+    type: "repo";
+};
+export type ActionParamDef = TextActionParam | LongTextActionParam | SelectActionParam | TemplateSelectActionParam | AgentActionParam | RepoActionParam;
+export type AgentParamValue = {
+    agent: string;
+    model: string;
+};
+export type RepoParamValue = {
+    repo: string;
+    branch: string;
+};
+export type ActionParamValue = string | AgentParamValue | RepoParamValue;
+export type ActionTargetMap = {
+    ticket: TicketListItem;
+    workspace: WorkspaceListItem;
+    session: Session;
+};
+type ActionTriggerContextBase = {
+    client: PstdioClient;
+    projectId: string;
+    prompts: Record<string, string>;
+    params: Record<string, ActionParamValue>;
+};
+export type ActionTriggerContext<TTargetType extends TargetType = TargetType> = ActionTriggerContextBase & (TTargetType extends TargetType ? {
+    targetType: TTargetType;
+    targetId: string;
+    target: ActionTargetMap[TTargetType];
+} : never);
+export type ActionInput = {
+    [K in TargetType]: {
+        key: string;
+        label: string;
+        targetType: K;
+        placement: ActionPlacement;
+        params?: ActionParamDef[];
+        trigger: (ctx: ActionTriggerContext<K>) => void | Promise<void>;
+    };
+}[TargetType];
+export type ActionDescriptor = {
+    key: string;
+    label: string;
+    targetType: TargetType;
+    placement: ActionPlacement;
+    params?: ActionParamDef[];
+};
+export type ActionDefinition = ActionDescriptor & {
+    trigger: (ctx: ActionTriggerContext) => void | Promise<void>;
+};
+export type PluginDefinition = {
+    key?: string;
+    actions?: ActionInput[];
+    hooks?: PluginHooks;
+};
+export {};

package/dist/prompts/index.d.ts

@@ -0,0 +1 @@
+export { renderPrompt } from "./render-prompt";

package/dist/prompts/index.js

@@ -0,0 +1,6 @@
+// src/prompts/render-prompt.ts
+import Mustache from "mustache";
+var renderPrompt = (template, data) => Mustache.render(template, data);
+export {
+  renderPrompt
+};

package/dist/prompts/render-prompt.d.ts

@@ -0,0 +1 @@
+export declare const renderPrompt: (template: string, data: Record<string, unknown>) => string;

package/dist/resources/agent.d.ts

@@ -0,0 +1 @@
+export type { AgentAvailabilityType, AgentConfig, AgentInfo, AgentModel } from "pstdio-api-contracts";

package/dist/resources/file.d.ts

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

package/dist/resources/index.d.ts

@@ -0,0 +1,11 @@
+export type { Repo } from "pstdio-api-contracts";
+export type { AgentAvailabilityType, AgentConfig, AgentInfo, AgentModel } from "./agent";
+export type { FileRecord } from "./file";
+export type { Project } from "./project";
+export type { Session, SessionStatus } from "./session";
+export type { Skill, SkillWithContent } from "./skill";
+export type { AttemptStatus, Status } from "./status";
+export type { Tag, TagOption } from "./tag";
+export type { Template, TemplateType, TemplateWithContent } from "./template";
+export type { Ticket, TicketDetail, TicketFile, TicketListItem } from "./ticket";
+export type { Workspace, WorkspaceListItem } from "./workspace";

package/dist/resources/project.d.ts

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

package/dist/resources/session.d.ts

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

package/dist/resources/skill.d.ts

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

package/dist/resources/status.d.ts

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

package/dist/resources/tag.d.ts

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

package/dist/resources/template.d.ts

@@ -0,0 +1 @@
+export type { Template, TemplateType, TemplateWithContent } from "pstdio-api-contracts";

package/dist/resources/ticket.d.ts

@@ -0,0 +1 @@
+export type { FileRecord as TicketFile, Ticket, TicketDetail, TicketListItem } from "pstdio-api-contracts";

package/dist/resources/workspace.d.ts

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

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@pstdio/sdk",
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pufflyai/prompt-studio"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    "./resources": {
+      "import": "./dist/resources/index.js",
+      "types": "./dist/resources/index.d.ts"
+    },
+    "./api": {
+      "import": "./dist/api/index.js",
+      "types": "./dist/api/index.d.ts"
+    },
+    "./client": {
+      "import": "./dist/client/index.js",
+      "types": "./dist/client/index.d.ts"
+    },
+    "./plugins": {
+      "import": "./dist/plugins/index.js",
+      "types": "./dist/plugins/index.d.ts"
+    },
+    "./prompts": {
+      "import": "./dist/prompts/index.js",
+      "types": "./dist/prompts/index.d.ts"
+    },
+    "./hooks": {
+      "import": "./dist/hooks/index.js",
+      "types": "./dist/hooks/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf ./dist && bun run build:js && bun run build:types",
+    "build:js": "bun build ./src/api/index.ts ./src/client/index.ts ./src/plugins/index.ts ./src/prompts/index.ts ./src/hooks/index.ts ./src/resources/index.ts --outdir ./dist --root ./src --target node --format esm --packages external",
+    "build:types": "tsc --project ./tsconfig.build.json",
+    "prepack": "bun run build",
+    "typecheck": "tsc --noEmit",
+    "lint": "bun run typecheck && biome check .",
+    "format": "biome check --write .",
+    "test": "bun test --silent",
+    "test:coverage": "bun test --coverage"
+  },
+  "dependencies": {
+    "mustache": "^4.2.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/mustache": "^4.2.6",
+    "pstdio-api-contracts": "workspace:*",
+    "typescript": "^5.9.3"
+  }
+}