@sideboard-ai/core 0.1.264 → 0.1.267

package/dist/chunk-KZ2CDZBZ.js

@@ -0,0 +1,828 @@
+#!/usr/bin/env node
+
+import {
+  abletimeRestUrl,
+  textFromAbleTimeDoc
+} from "./chunk-DBFAFI5A.js";
+import {
+  assertAbleTimeCredential,
+  callAbleTimeTool,
+  normalizeAbleTimeHost,
+  rewriteAbleTimeError
+} from "./chunk-GONPMH36.js";
+import {
+  httpFetch
+} from "./chunk-VKQGAWHY.js";
+import {
+  ATTACHMENTS_DIR,
+  attachmentsGitignoreBody
+} from "./chunk-N2WW62LF.js";
+import {
+  getAbleTimeAccessToken,
+  getAbleTimeHost,
+  isAbleTimeConnected,
+  saveAbleTimeConnection
+} from "./chunk-OIENQEGG.js";
+
+// src/integrations/issue-attachments.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { basename, extname, join } from "path";
+import { randomUUID } from "crypto";
+var ISSUE_ATTACHMENT_MAX_BYTES = 25 * 1024 * 1024;
+var MARKDOWN_IMAGE_RE = /!\[[^\]]*]\(\s*<?(https?:\/\/[^)\s>]+)>?/gi;
+var MARKDOWN_LINK_RE = /(?<!!)\[[^\]]*]\(\s*<?(https?:\/\/[^)\s>]+)>?/gi;
+var HTML_SRC_RE = /\b(?:src|href)\s*=\s*["'](https?:\/\/[^"']+)["']/gi;
+var BARE_URL_RE = /https?:\/\/[^\s<>"'`)]+/gi;
+var EXT_BY_MIME = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/jpg": ".jpg",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/svg+xml": ".svg",
+  "application/pdf": ".pdf",
+  "text/plain": ".txt",
+  "text/markdown": ".md",
+  "application/json": ".json",
+  "application/zip": ".zip"
+};
+function issueAttachmentWorktreePath(repoPath) {
+  const raw = (repoPath ?? "").trim();
+  return raw || process.cwd();
+}
+function ensureIssueAttachmentsDir(worktreePath) {
+  const dir = join(worktreePath, ATTACHMENTS_DIR);
+  mkdirSync(dir, { recursive: true });
+  const gi = join(dir, ".gitignore");
+  if (!existsSync(gi)) {
+    writeFileSync(gi, attachmentsGitignoreBody(), "utf8");
+  }
+  return dir;
+}
+function hostnameOf(url) {
+  try {
+    return new URL(url).hostname.toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function hostMatches(url, suffixes) {
+  const host = hostnameOf(url);
+  if (!host) return false;
+  return suffixes.some((suffix) => host === suffix || host.endsWith(`.${suffix}`));
+}
+function looksLikeHttpUrl(value) {
+  return /^https?:\/\//i.test(value.trim());
+}
+function looksLikeFileUrl(url) {
+  try {
+    const path = new URL(url).pathname;
+    return /\.[a-z0-9]{2,8}$/i.test(path);
+  } catch {
+    return false;
+  }
+}
+function filenameFromUrl(url, fallback = "attachment") {
+  try {
+    const parsed = new URL(url);
+    const last = decodeURIComponent(basename(parsed.pathname)).replace(/[/\\]/g, "_");
+    if (last && last !== "/" && last !== ".") return last;
+  } catch {
+  }
+  return fallback;
+}
+function filenameFromContentDisposition(header) {
+  if (!header) return void 0;
+  const star = header.match(/filename\*\s*=\s*(?:UTF-8''|utf-8'')([^;]+)/i);
+  if (star?.[1]) {
+    try {
+      return decodeURIComponent(star[1].trim().replace(/^["']|["']$/g, ""));
+    } catch {
+      return star[1].trim().replace(/^["']|["']$/g, "");
+    }
+  }
+  const plain = header.match(/filename\s*=\s*("(?:\\.|[^"])*"|[^;]+)/i);
+  if (!plain?.[1]) return void 0;
+  return plain[1].trim().replace(/^["']|["']$/g, "").replace(/\\"/g, '"');
+}
+function uniqueAttachmentFileName(dir, originalName) {
+  const safe = originalName.replace(/[/\\]/g, "_").replace(/^\.+/, "") || "file";
+  if (!existsSync(join(dir, safe))) return safe;
+  const ext = extname(safe);
+  const stem = ext ? safe.slice(0, -ext.length) : safe;
+  for (let i = 1; i < 1e4; i++) {
+    const candidate = `${stem}-${i}${ext}`;
+    if (!existsSync(join(dir, candidate))) return candidate;
+  }
+  return `${stem}-${randomUUID()}${ext}`;
+}
+function extractHttpUrls(markdown) {
+  const text = markdown ?? "";
+  if (!text.trim()) return [];
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (raw) => {
+    const url = raw.replace(/[).,;]+$/, "");
+    if (!looksLikeHttpUrl(url) || seen.has(url)) return;
+    seen.add(url);
+    found.push(url);
+  };
+  for (const re of [MARKDOWN_IMAGE_RE, MARKDOWN_LINK_RE, HTML_SRC_RE, BARE_URL_RE]) {
+    re.lastIndex = 0;
+    let match;
+    while (match = re.exec(text)) {
+      if (match[1]) push(match[1]);
+      else if (re === BARE_URL_RE) push(match[0]);
+    }
+  }
+  return found;
+}
+function mergeIssueAttachments(items) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (!item) continue;
+    const url = item.url.trim();
+    const id = item.id.trim() || url;
+    if (!id && !url) continue;
+    const key = url || id;
+    if (seen.has(key) || seen.has(id)) continue;
+    seen.add(key);
+    if (id !== key) seen.add(id);
+    out.push({
+      id: id || url,
+      name: item.name.trim() || filenameFromUrl(url),
+      url,
+      ...item.contentType ? { contentType: item.contentType } : {},
+      ...item.sourceType ? { sourceType: item.sourceType } : {}
+    });
+  }
+  return out;
+}
+function extensionForContentType(contentType, name) {
+  if (extname(name)) return name;
+  const mime = (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+  const ext = EXT_BY_MIME[mime];
+  return ext ? `${name}${ext}` : name;
+}
+function assertNotHtml(contentType, url) {
+  const mime = (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+  if (mime === "text/html" || mime === "application/xhtml+xml") {
+    throw new Error(
+      `Attachment at ${url} returned HTML, not a file. Use the listed file URL (uploads / user-attachments), not a ticket or PR page.`
+    );
+  }
+}
+async function downloadAuthenticatedFile(opts) {
+  const url = opts.url.trim();
+  if (!looksLikeHttpUrl(url)) {
+    throw new Error(`Attachment URL must be http(s) (got ${url || "empty"})`);
+  }
+  const res = await httpFetch(url, {
+    method: "GET",
+    redirect: "follow",
+    headers: {
+      Accept: "*/*",
+      ...opts.headers ?? {}
+    }
+  });
+  if (!res.ok) {
+    const detail = await res.text().catch(() => "");
+    throw new Error(
+      `Attachment download failed ${res.status}${detail ? `: ${detail.slice(0, 200)}` : ""} (${url})`
+    );
+  }
+  const contentType = res.headers.get("content-type") ?? void 0;
+  assertNotHtml(contentType, url);
+  const lengthHeader = res.headers.get("content-length");
+  if (lengthHeader) {
+    const length = Number(lengthHeader);
+    if (Number.isFinite(length) && length > ISSUE_ATTACHMENT_MAX_BYTES) {
+      throw new Error(
+        `Attachment is ${length} bytes; max is ${ISSUE_ATTACHMENT_MAX_BYTES} (${url})`
+      );
+    }
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  if (buf.length > ISSUE_ATTACHMENT_MAX_BYTES) {
+    throw new Error(
+      `Attachment is ${buf.length} bytes; max is ${ISSUE_ATTACHMENT_MAX_BYTES} (${url})`
+    );
+  }
+  const dir = ensureIssueAttachmentsDir(opts.worktreePath);
+  const hinted = opts.name?.trim() || filenameFromContentDisposition(res.headers.get("content-disposition")) || filenameFromUrl(url);
+  const name = uniqueAttachmentFileName(dir, extensionForContentType(contentType, hinted));
+  writeFileSync(join(dir, name), buf);
+  return {
+    name,
+    path: `${ATTACHMENTS_DIR}/${name}`,
+    bytes: buf.length,
+    ...contentType ? { contentType } : {}
+  };
+}
+
+// src/integrations/abletime-attachments.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function asList(value) {
+  if (Array.isArray(value)) return value;
+  const record = asRecord(value);
+  if (!record) return [];
+  for (const key of ["data", "tasks", "projects", "items", "results", "nodes"]) {
+    if (Array.isArray(record[key])) return record[key];
+  }
+  return [];
+}
+function firstString(record, keys) {
+  if (!record) return "";
+  for (const key of keys) {
+    const value = asString(record[key]);
+    if (value) return value;
+  }
+  return "";
+}
+function filesFromAbleTimeDoc(value) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    const rec = asRecord(node);
+    if (!rec) return;
+    const attrs = asRecord(rec.attrs) ?? rec;
+    const url = asString(attrs.src) || asString(attrs.href) || asString(attrs.url) || asString(attrs.fileUrl) || asString(attrs.downloadUrl);
+    if (url && !seen.has(url)) {
+      seen.add(url);
+      out.push({
+        id: asString(attrs.id) || asString(attrs.fileId) || void 0,
+        name: asString(attrs.name) || asString(attrs.title) || asString(attrs.filename) || asString(attrs.alt) || "attachment",
+        url
+      });
+    }
+    if (Array.isArray(rec.content)) rec.content.forEach(walk);
+  };
+  walk(value);
+  return out;
+}
+function listedAbleTimeFiles(raw) {
+  const out = [];
+  for (const item of asList(raw)) {
+    const rec = asRecord(item);
+    if (!rec) continue;
+    const url = firstString(rec, ["url", "href", "src", "fileUrl", "downloadUrl", "permalink"]);
+    if (!url) continue;
+    const id = firstString(rec, ["id", "fileId", "attachmentId"]) || url;
+    const name = firstString(rec, ["name", "title", "filename", "fileName", "alt"]) || "attachment";
+    out.push({ id, name, url });
+  }
+  return out;
+}
+function mapAbleTimeAttachments(record) {
+  const listed = [
+    ...listedAbleTimeFiles(record.attachments),
+    ...listedAbleTimeFiles(record.files),
+    ...listedAbleTimeFiles(record.media)
+  ];
+  const fromDocs = [
+    ...filesFromAbleTimeDoc(record.description),
+    ...filesFromAbleTimeDoc(record.content),
+    ...asList(record.comments).flatMap((item) => {
+      const rec = asRecord(item);
+      return rec ? filesFromAbleTimeDoc(rec.content ?? rec.body) : [];
+    })
+  ].map((file) => ({
+    id: file.id || file.url,
+    name: file.name,
+    url: file.url
+  }));
+  const fromText = extractHttpUrls(
+    firstString(record, ["description", "body", "descriptionSanitized"]) || textFromAbleTimeDoc(record.description)
+  ).filter(looksLikeFileUrl).map((url) => ({
+    id: url,
+    name: url.split("/").pop() || "attachment",
+    url
+  }));
+  return mergeIssueAttachments([...listed, ...fromDocs, ...fromText]);
+}
+function ableTimeFileHostSuffixes(host) {
+  try {
+    const hostname = new URL(normalizeAbleTimeHost(host)).hostname.toLowerCase();
+    const parts = hostname.split(".");
+    const root = parts.slice(-2).join(".");
+    return Array.from(/* @__PURE__ */ new Set([hostname, root, "abletime.com"]));
+  } catch {
+    return ["abletime.com"];
+  }
+}
+async function resolveAbleTimeAttachmentUrl(id, opts) {
+  for (const path of [`/files/${encodeURIComponent(id)}`, `/attachments/${encodeURIComponent(id)}`]) {
+    const res = await httpFetch(abletimeRestUrl(path, opts.host), {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${opts.token}`
+      }
+    });
+    if (!res.ok) continue;
+    const contentType = (res.headers.get("content-type") ?? "").toLowerCase();
+    if (!contentType.includes("json")) continue;
+    const json = await res.json().catch(() => null);
+    const rec = json && typeof json === "object" && !Array.isArray(json) ? json.data && typeof json.data === "object" ? json.data : json : null;
+    if (!rec) continue;
+    const url = firstString(rec, ["url", "href", "src", "fileUrl", "downloadUrl"]) || firstString(asRecord(rec.file), ["url", "href"]);
+    if (url) {
+      return {
+        url,
+        name: firstString(rec, ["name", "title", "filename", "fileName"]) || void 0
+      };
+    }
+  }
+  throw new Error(`AbleTime attachment not found: ${id}`);
+}
+async function downloadAbleTimeAttachment(input, opts) {
+  const id = input.id.trim();
+  if (!id) throw new Error("AbleTime attachment id or URL is required");
+  const token = assertAbleTimeCredential(opts?.token ?? getAbleTimeAccessToken() ?? "");
+  const host = normalizeAbleTimeHost(opts?.host ?? getAbleTimeHost());
+  let url = id;
+  let name = input.name?.trim();
+  if (!looksLikeHttpUrl(id)) {
+    const resolved = await resolveAbleTimeAttachmentUrl(id, { token, host });
+    url = resolved.url;
+    name = name || resolved.name;
+  }
+  const sendAuth = hostMatches(url, ableTimeFileHostSuffixes(host));
+  return downloadAuthenticatedFile({
+    url,
+    headers: sendAuth ? { Authorization: `Bearer ${token}` } : void 0,
+    worktreePath: issueAttachmentWorktreePath(opts?.destPath),
+    name
+  });
+}
+
+// src/integrations/abletime.ts
+var CLOSED_STATES = /* @__PURE__ */ new Set(["done", "completed", "canceled", "cancelled", "archived", "closed"]);
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString2(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function firstString2(record, keys) {
+  if (!record) return "";
+  for (const key of keys) {
+    const value = asString2(record[key]);
+    if (value) return value;
+  }
+  return "";
+}
+function firstRecord(record, keys) {
+  if (!record) return null;
+  for (const key of keys) {
+    const value = asRecord2(record[key]);
+    if (value) return value;
+  }
+  return null;
+}
+function asList2(value) {
+  if (Array.isArray(value)) return value;
+  const record = asRecord2(value);
+  if (!record) return [];
+  for (const key of ["data", "tasks", "projects", "items", "results", "nodes"]) {
+    if (Array.isArray(record[key])) return record[key];
+  }
+  return [];
+}
+function labelsOf(record) {
+  const raw = record.tags ?? record.labels ?? record.tag_names;
+  if (!Array.isArray(raw)) return [];
+  return raw.map((item) => {
+    if (typeof item === "string") return item.trim();
+    const rec = asRecord2(item);
+    return rec ? firstString2(rec, ["name", "title", "label"]) : "";
+  }).filter(Boolean);
+}
+function commentsOf(record) {
+  const out = [];
+  for (const item of asList2(record.comments ?? record.notes ?? record.discussion)) {
+    const rec = asRecord2(item);
+    if (!rec) continue;
+    const body = firstString2(rec, ["body", "text", "comment", "message", "contentSanitized"]) || textFromAbleTimeDoc(rec.content);
+    if (!body) continue;
+    const user = firstString2(asRecord2(rec.user) ?? asRecord2(rec.author), ["name", "display_name", "username"]) || firstString2(rec, ["user_name", "author", "username"]);
+    const id = firstString2(rec, ["id", "comment_id", "commentId"]);
+    const url = firstString2(rec, ["url", "permalink"]);
+    const createdAt = firstString2(rec, ["created_at", "createdAt", "created"]);
+    out.push({
+      body,
+      ...id ? { id } : {},
+      ...url ? { url } : {},
+      ...createdAt ? { createdAt } : {},
+      ...user ? { user } : {}
+    });
+  }
+  return out;
+}
+function assigneeOf(record) {
+  const nested = firstRecord(record, ["assignee", "assigned_to", "user", "owner"]);
+  const name = firstString2(nested, ["name", "display_name", "full_name", "email"]) || firstString2(record, ["assignee_name", "assigneeName"]);
+  if (!name) return void 0;
+  const id = firstString2(nested, ["id", "user_id"]);
+  return { id: id || void 0, name };
+}
+function taskUrl(task, host) {
+  const base = normalizeAbleTimeHost(host);
+  const slug = encodeURIComponent(task.identifier || task.id);
+  return `${base}/tasks/${slug}`;
+}
+function mapAbleTimeTask(raw, host) {
+  const record = asRecord2(raw);
+  if (!record) return null;
+  const nested = firstRecord(record, ["task", "data"]) ?? record;
+  const id = firstString2(nested, ["id", "task_id", "taskId", "timeflowTaskId"]);
+  const identifier = firstString2(nested, ["reference", "ref", "identifier", "key", "code", "number", "taskRef"]) || id;
+  const title = firstString2(nested, ["title", "name"]);
+  if (!id && !identifier && !title) return null;
+  const resolvedId = id || identifier;
+  const resolvedIdentifier = identifier || id;
+  const url = firstString2(nested, ["url", "permalink", "html_url"]) || taskUrl({ id: resolvedId, identifier: resolvedIdentifier }, host);
+  return {
+    id: resolvedId,
+    identifier: resolvedIdentifier,
+    title: title || resolvedIdentifier,
+    url,
+    description: firstString2(nested, ["description", "body", "details", "descriptionSanitized"]) || textFromAbleTimeDoc(nested.description) || void 0,
+    state: firstString2(nested, ["state", "board_state", "boardState", "status", "taskState"]) || void 0,
+    projectId: firstString2(nested, ["project_id", "projectId"]) || firstString2(asRecord2(nested.project), ["id"]) || void 0,
+    categoryId: firstString2(nested, ["category_id", "categoryId", "projectCategoryId"]) || firstString2(asRecord2(nested.category), ["id"]) || void 0,
+    assignee: assigneeOf(nested),
+    labels: labelsOf(nested),
+    comments: commentsOf(nested),
+    attachments: mapAbleTimeAttachments(nested),
+    createdAt: firstString2(nested, ["created_at", "createdAt", "created", "dateCreated"]) || void 0,
+    updatedAt: firstString2(nested, [
+      "updated_at",
+      "updatedAt",
+      "modified_at",
+      "modifiedAt",
+      "last_activity_at",
+      "lastActivityAt",
+      "lastUpdate"
+    ]) || void 0
+  };
+}
+function toAbleTimeIssueInfo(task) {
+  return {
+    id: task.id || task.identifier,
+    identifier: task.identifier,
+    title: task.title,
+    url: task.url,
+    labels: task.labels,
+    provider: "abletime",
+    assignee: task.assignee?.name,
+    assignees: task.assignee?.name ? [task.assignee.name] : void 0,
+    ...task.createdAt ? { createdAt: task.createdAt } : {},
+    ...task.updatedAt ? { updatedAt: task.updatedAt } : {}
+  };
+}
+function issueAttachmentForAbleTimeTask(task) {
+  return {
+    id: `abletime-${task.id || task.identifier}`,
+    name: task.identifier || task.title,
+    kind: "issue",
+    content: [
+      `Linked issue: ${task.identifier} \u2014 ${task.title}`,
+      task.url ? `URL: ${task.url}` : null,
+      task.labels.length ? `Labels: ${task.labels.join(", ")}` : null
+    ].filter(Boolean).join("\n")
+  };
+}
+function mapProject(raw) {
+  const record = asRecord2(raw);
+  if (!record) return null;
+  const id = firstString2(record, ["id", "project_id", "projectId"]);
+  const name = firstString2(record, ["name", "title", "projectName"]);
+  if (!id && !name) return null;
+  const categories = asList2(record.categories ?? record.category).map((item) => {
+    const rec = asRecord2(item);
+    if (!rec) return null;
+    const categoryId = firstString2(rec, ["id", "category_id", "projectCategoryId", "categoryId"]);
+    const categoryName = firstString2(rec, ["name", "title", "categoryName"]);
+    if (!categoryId && !categoryName) return null;
+    return { id: categoryId || categoryName, name: categoryName || categoryId };
+  }).filter((item) => Boolean(item));
+  return { id: id || name, name: name || id, categories };
+}
+function isOpenTask(task) {
+  const state = (task.state ?? "").toLowerCase();
+  return !state || !CLOSED_STATES.has(state);
+}
+async function getAbleTimeOrientation(opts) {
+  const raw = await callAbleTimeTool("orientation", {}, opts);
+  const record = asRecord2(raw);
+  const viewerRec = firstRecord(record, ["viewer", "principal", "user", "actor", "me", "person"]) ?? record;
+  const viewer = {
+    id: firstString2(viewerRec, ["id", "user_id"]) || void 0,
+    name: firstString2(viewerRec, ["name", "display_name", "full_name"]) || firstString2(record, ["name"]) || void 0
+  };
+  const projects = asList2(
+    record?.projects ?? record?.current_projects ?? record?.currentProjects
+  ).map(mapProject).filter((item) => Boolean(item));
+  const tasks = asList2(record?.tasks ?? record?.active_tasks ?? record?.activeTasks).map((item) => mapAbleTimeTask(item, opts?.host)).filter((item) => Boolean(item));
+  return { viewer, projects, tasks, raw };
+}
+async function listAbleTimeProjects(opts) {
+  const raw = await callAbleTimeTool("list_projects", { include_categories: true }, opts);
+  return asList2(raw).map(mapProject).filter((item) => Boolean(item));
+}
+async function listAbleTimeTasks(opts) {
+  const args = {};
+  if (opts?.projectId) {
+    args.project_id = opts.projectId;
+    args.project = opts.projectId;
+  }
+  if (opts?.query) args.query = opts.query;
+  const raw = await callAbleTimeTool("list_tasks", args, opts);
+  const tasks = asList2(raw).map((item) => mapAbleTimeTask(item, opts?.host)).filter((item) => Boolean(item));
+  return opts?.includeClosed ? tasks : tasks.filter(isOpenTask);
+}
+async function searchAbleTimeTasks(query, opts) {
+  const q = query.trim();
+  if (!q) return [];
+  const raw = await callAbleTimeTool("search_tasks", { query: q, q }, opts);
+  return asList2(raw).map((item) => mapAbleTimeTask(item, opts?.host)).filter((item) => Boolean(item)).filter(isOpenTask);
+}
+async function getAbleTimeTask(id, opts) {
+  const raw = await callAbleTimeTool("get_task", { id, task_id: id }, opts);
+  const task = mapAbleTimeTask(raw, opts?.host);
+  if (!task) throw new Error(`AbleTime task not found: ${id}`);
+  return task;
+}
+async function createAbleTimeTask(input, opts) {
+  const title = input.title.trim();
+  if (!title) throw new Error("AbleTime task title is required");
+  const project = await resolveAbleTimeProject(input.projectId, opts);
+  const category = resolveAbleTimeCategory(project, input.categoryId);
+  const parent = input.parent?.trim();
+  const descriptionParts = [
+    parent ? `Spin-off of ${parent}.` : null,
+    input.description?.trim() || null
+  ].filter(Boolean);
+  const raw = await callAbleTimeTool(
+    "create_task",
+    {
+      title,
+      description: descriptionParts.join("\n\n") || void 0,
+      state: input.state ?? "todo",
+      project: project.id,
+      project_id: project.id,
+      category: category?.id,
+      category_id: category?.id,
+      parent,
+      parent_id: parent,
+      related_task_id: parent
+    },
+    opts
+  );
+  const task = mapAbleTimeTask(raw, opts?.host);
+  if (!task) throw new Error("AbleTime create_task returned no task");
+  return task;
+}
+async function commentAbleTimeTask(input, opts) {
+  const id = input.id.trim();
+  const body = input.body.trim();
+  if (!id) throw new Error("AbleTime task id is required");
+  if (!body) throw new Error("AbleTime comment body is required");
+  const raw = await callAbleTimeTool(
+    "create_comment",
+    { id, task_id: id, task: id, body, comment: body, text: body },
+    opts
+  );
+  const rec = asRecord2(raw);
+  return {
+    id: rec ? firstString2(rec, ["id", "comment_id"]) || void 0 : void 0,
+    body: rec ? firstString2(rec, ["body", "text", "comment"]) || body : body
+  };
+}
+function isAbleTimeNoneToken(value) {
+  if (value == null) return true;
+  const s = value.trim();
+  return !s || /^(none|clear|unschedule|null)$/i.test(s);
+}
+function taskIdArgs(id) {
+  return { id, task_id: id, task: id };
+}
+function ableTimeDependencyTarget(thisId, type, relatedId) {
+  const s = type.trim().toLowerCase().replace(/[\s_-]+/g, "");
+  if (s === "none" || s === "clear" || s === "null") {
+    return { taskId: thisId, dependsOn: null };
+  }
+  if (s === "blockedby" || s === "blocked" || s === "dependson" || s === "waiton") {
+    return { taskId: thisId, dependsOn: relatedId };
+  }
+  if (s === "blocks" || s === "blocking") {
+    return { taskId: relatedId, dependsOn: thisId };
+  }
+  throw new Error(
+    `AbleTime relation type must be blocks or blockedBy (got ${type}). AbleTime models one wait-on dependency.`
+  );
+}
+async function setAbleTimeTaskDependency(taskId, dependsOn, opts) {
+  const args = {
+    ...taskIdArgs(taskId)
+  };
+  if (dependsOn) {
+    args.depends_on = dependsOn;
+    args.depends_on_id = dependsOn;
+    args.dependency = dependsOn;
+    args.dependency_id = dependsOn;
+    args.blocked_by = dependsOn;
+    args.wait_on = dependsOn;
+    args.related_task_id = dependsOn;
+  } else {
+    args.depends_on = null;
+    args.dependency = null;
+    args.blocked_by = null;
+    args.clear = true;
+  }
+  await callAbleTimeTool("set_task_dependency", args, opts);
+}
+async function updateAbleTimeTask(input, opts) {
+  const id = input.id.trim();
+  if (!id) throw new Error("AbleTime task id is required");
+  const title = input.title?.trim();
+  const description = input.description;
+  const state = input.state?.trim();
+  const addRelations = input.relations?.length ? input.relations : void 0;
+  const removeRelations = input.removeRelations?.length ? input.removeRelations : void 0;
+  const updateArgs = { ...taskIdArgs(id) };
+  if (title) updateArgs.title = title;
+  if (description !== void 0) updateArgs.description = description;
+  if (input.labels !== void 0) {
+    updateArgs.tags = input.labels;
+    updateArgs.labels = input.labels;
+    updateArgs.tag_names = input.labels;
+  }
+  if (input.project !== void 0) {
+    const projectName = (input.project ?? "").trim();
+    if (isAbleTimeNoneToken(projectName)) {
+      throw new Error("AbleTime tasks stay in a project \u2014 pass a project name or id");
+    }
+    const project = await resolveAbleTimeProject(projectName, opts);
+    updateArgs.project = project.id;
+    updateArgs.project_id = project.id;
+  }
+  if (input.parent !== void 0) {
+    if (isAbleTimeNoneToken(input.parent)) {
+      updateArgs.parent = null;
+      updateArgs.parent_id = null;
+      updateArgs.related_task_id = null;
+    } else {
+      const parent = (input.parent ?? "").trim();
+      updateArgs.parent = parent;
+      updateArgs.parent_id = parent;
+      updateArgs.related_task_id = parent;
+    }
+  }
+  const hasUpdateFields = Boolean(title) || description !== void 0 || input.labels !== void 0 || input.project !== void 0 || input.parent !== void 0;
+  if (!hasUpdateFields && !state && !addRelations && !removeRelations) {
+    throw new Error(
+      "abletime_update_task needs at least one of title, description, state, labels, project, parent, relations, removeRelations"
+    );
+  }
+  if (state) {
+    await callAbleTimeTool(
+      "set_task_state",
+      { ...taskIdArgs(id), state },
+      opts
+    ).catch(async () => {
+      await callAbleTimeTool(
+        "update_task",
+        { ...updateArgs, state },
+        opts
+      );
+    });
+  }
+  if (hasUpdateFields) {
+    await callAbleTimeTool("update_task", updateArgs, opts);
+  }
+  for (const rel of removeRelations ?? []) {
+    const related = rel.issue.trim() || id;
+    const target = ableTimeDependencyTarget(id, rel.type, related);
+    await setAbleTimeTaskDependency(target.taskId, null, opts);
+  }
+  for (const rel of addRelations ?? []) {
+    const related = rel.issue.trim();
+    if (!related) throw new Error("AbleTime relations.issue is required (id or CRM-232)");
+    const target = ableTimeDependencyTarget(id, rel.type, related);
+    if (!target.dependsOn) {
+      await setAbleTimeTaskDependency(target.taskId, null, opts);
+      continue;
+    }
+    await setAbleTimeTaskDependency(target.taskId, target.dependsOn, opts);
+  }
+  return getAbleTimeTask(id, opts);
+}
+async function resolveAbleTimeProject(projectId, opts) {
+  const wanted = projectId?.trim().toLowerCase();
+  const fromOrientation = (await getAbleTimeOrientation(opts).catch(() => null))?.projects ?? [];
+  const listed = fromOrientation.length > 0 ? fromOrientation : await listAbleTimeProjects(opts);
+  if (listed.length === 0) {
+    throw new Error(
+      rewriteAbleTimeError(
+        "AbleTime has no projects to create a task in \u2014 create a project in AbleTime first."
+      )
+    );
+  }
+  if (!wanted) return listed[0];
+  const found = listed.find(
+    (project) => project.id.toLowerCase() === wanted || project.name.toLowerCase() === wanted
+  );
+  if (!found) {
+    const names = listed.map((project) => project.name).join(", ") || "(none)";
+    throw new Error(`AbleTime project not found: ${projectId}. Known: ${names}`);
+  }
+  return found;
+}
+function resolveAbleTimeCategory(project, categoryId) {
+  if (project.categories.length === 0) return void 0;
+  const wanted = categoryId?.trim().toLowerCase();
+  if (!wanted) return project.categories[0];
+  return project.categories.find(
+    (category) => category.id.toLowerCase() === wanted || category.name.toLowerCase() === wanted
+  ) ?? project.categories[0];
+}
+function titlesMatch(a, b) {
+  return a.trim().toLowerCase() === b.trim().toLowerCase();
+}
+async function ensureAbleTimeTask(input, opts) {
+  const title = input.title.trim();
+  if (!title) throw new Error("AbleTime task title is required");
+  const searched = await searchAbleTimeTasks(title, opts).catch(() => []);
+  const exact = searched.find((task) => titlesMatch(task.identifier, title)) || searched.find((task) => titlesMatch(task.title, title));
+  if (exact) return { ...exact, created: false };
+  const created = await createAbleTimeTask(
+    {
+      title,
+      description: input.description,
+      projectId: input.projectId,
+      categoryId: input.categoryId,
+      state: "todo"
+    },
+    opts
+  );
+  return { ...created, created: true };
+}
+async function listAbleTimeAssignedIssues(opts) {
+  if (!opts?.token && !isAbleTimeConnected()) {
+    throw new Error("AbleTime is not connected \u2014 paste a personal access token in Account settings");
+  }
+  const [orientation, listed] = await Promise.all([
+    getAbleTimeOrientation(opts).catch(() => null),
+    listAbleTimeTasks(opts)
+  ]);
+  const issues = listed.map(toAbleTimeIssueInfo);
+  return {
+    viewer: orientation?.viewer ?? {},
+    issues
+  };
+}
+async function verifyAbleTimeConnection(input) {
+  const token = assertAbleTimeCredential(input.token);
+  const host = input.host?.trim() || void 0;
+  const orientation = await getAbleTimeOrientation({ token, host });
+  saveAbleTimeConnection({
+    accessToken: token,
+    host,
+    viewerName: orientation.viewer.name
+  });
+  return orientation.viewer;
+}
+
+export {
+  issueAttachmentWorktreePath,
+  hostMatches,
+  looksLikeHttpUrl,
+  extractHttpUrls,
+  mergeIssueAttachments,
+  downloadAuthenticatedFile,
+  downloadAbleTimeAttachment,
+  taskUrl,
+  mapAbleTimeTask,
+  toAbleTimeIssueInfo,
+  issueAttachmentForAbleTimeTask,
+  getAbleTimeOrientation,
+  listAbleTimeProjects,
+  listAbleTimeTasks,
+  searchAbleTimeTasks,
+  getAbleTimeTask,
+  createAbleTimeTask,
+  commentAbleTimeTask,
+  ableTimeDependencyTarget,
+  updateAbleTimeTask,
+  ensureAbleTimeTask,
+  listAbleTimeAssignedIssues,
+  verifyAbleTimeConnection
+};