@co0ontty/wand 4.55.3 → 4.56.0

package/vendor/codex-taskboard/shared/task-input.mjs

@@ -0,0 +1,308 @@
+import { DEFAULT_PROJECT_ID, isTaskStatus } from "./domain.mjs";
+import {
+  ApiError, assertPlainObject, assertAllowedKeys, stringField,
+  parseVersion, validateProjectId, parseThreadId, parseAssigneeTarget,
+  parseRelationOrigin, parseStatus, parsePriority, parseLabels,
+  parseSortOrder, parseDueDate, parseRecurrence,
+} from "./api-fields.mjs";
+
+export function parseThreadBinding(value) {
+  if (value === undefined || value === null) return value;
+  assertPlainObject(value);
+  assertAllowedKeys(value, new Set([
+    "threadId",
+    "codexProjectId",
+    "codexProjectKind",
+    "codexHostId",
+    "workspacePath",
+  ]));
+  const threadId = stringField(value.threadId, "threadBinding.threadId", {
+    required: true,
+    maxLength: 256,
+  });
+  const identityFields = [
+    value.codexProjectId,
+    value.codexProjectKind,
+    value.codexHostId,
+    value.workspacePath,
+  ];
+  if (identityFields.every((field) => field === undefined)) return { threadId };
+  if (identityFields.some((field) => field === undefined)) {
+    throw new ApiError(400, "INVALID_FIELD", "Thread identity must include project, kind, host, and workspace");
+  }
+  const codexProjectId = stringField(value.codexProjectId, "threadBinding.codexProjectId", {
+    required: true,
+    maxLength: 256,
+  });
+  const codexProjectKind = value.codexProjectKind;
+  const codexHostId = stringField(value.codexHostId, "threadBinding.codexHostId", {
+    required: true,
+    maxLength: 256,
+  });
+  const workspacePath = stringField(value.workspacePath, "threadBinding.workspacePath", {
+    required: true,
+    maxLength: 4096,
+  });
+  if (codexProjectKind !== "local" && codexProjectKind !== "remote") {
+    throw new ApiError(400, "INVALID_FIELD", "threadBinding.codexProjectKind must be local or remote");
+  }
+  if (
+    (codexProjectKind === "local" && codexHostId !== "local")
+    || (codexProjectKind === "remote" && codexHostId === "local")
+    || workspacePath.includes("\0")
+  ) {
+    throw new ApiError(400, "INVALID_FIELD", "Thread project identity is invalid");
+  }
+  return { threadId, codexProjectId, codexProjectKind, codexHostId, workspacePath };
+}
+
+export function parseMove(body) {
+  assertPlainObject(body);
+  assertAllowedKeys(body, new Set(["version", "status", "sortOrder", "threadId", "threadBinding"]));
+  return {
+    version: parseVersion(body.version),
+    status: parseStatus(body.status),
+    sortOrder: body.sortOrder === undefined ? undefined : parseSortOrder(body.sortOrder),
+    threadId: parseThreadId(body.threadId),
+    threadBinding: parseThreadBinding(body.threadBinding),
+  };
+}
+
+export function parseVersionMutation(body) {
+  assertPlainObject(body);
+  assertAllowedKeys(body, new Set(["version", "threadId", "threadBinding"]));
+  return {
+    version: parseVersion(body.version),
+    threadId: parseThreadId(body.threadId),
+    threadBinding: parseThreadBinding(body.threadBinding),
+  };
+}
+
+export function parseRelationMutation(body) {
+  assertPlainObject(body);
+  assertAllowedKeys(body, new Set(["version", "threadId", "threadBinding", "origin"]));
+  return {
+    version: parseVersion(body.version),
+    threadId: parseThreadId(body.threadId),
+    threadBinding: parseThreadBinding(body.threadBinding),
+    origin: parseRelationOrigin(body.origin),
+  };
+}
+
+export function parseCommentCreate(body) {
+  assertPlainObject(body);
+  assertAllowedKeys(body, new Set(["body", "threadId", "threadBinding"]));
+  return {
+    body: stringField(body.body ?? "", "body", { maxLength: 100_000 }),
+    threadId: parseThreadId(body.threadId),
+    threadBinding: parseThreadBinding(body.threadBinding),
+  };
+}
+
+export function parseCommentPatch(body) {
+  assertPlainObject(body);
+  assertAllowedKeys(body, new Set(["version", "body", "threadId", "threadBinding"]));
+  if (body.body === undefined) {
+    throw new ApiError(400, "INVALID_FIELD", "'body' is required");
+  }
+  return {
+    version: parseVersion(body.version),
+    body: stringField(body.body, "body", { maxLength: 100_000 }),
+    threadId: parseThreadId(body.threadId),
+    threadBinding: parseThreadBinding(body.threadBinding),
+  };
+}
+
+export function parseTaskCreate(body, parseDevelopmentContext) {
+  assertPlainObject(body);
+  assertAllowedKeys(body, new Set([
+    "projectId", "title", "description", "status", "priority", "labels", "sortOrder", "threadId", "threadBinding",
+    "assigneeTarget", "developmentContext", "startDate", "dueDate", "recurrence",
+  ]));
+  const projectId = validateProjectId(body.projectId ?? DEFAULT_PROJECT_ID);
+  const task = {
+    projectId,
+    title: stringField(body.title, "title", { required: true, maxLength: 240 }),
+    description: stringField(body.description ?? "", "description", { maxLength: 100_000 }),
+    status: parseStatus(body.status, "backlog"),
+    priority: parsePriority(body.priority, "none"),
+    labels: body.labels === undefined ? [] : parseLabels(body.labels),
+    sortOrder: body.sortOrder === undefined ? undefined : parseSortOrder(body.sortOrder),
+    threadId: parseThreadId(body.threadId),
+    threadBinding: parseThreadBinding(body.threadBinding),
+    assigneeTarget: parseAssigneeTarget(body.assigneeTarget),
+    developmentContext: parseDevelopmentContext(body.developmentContext ?? null),
+    startDate: parseDueDate(body.startDate ?? null, "startDate"),
+    dueDate: parseDueDate(body.dueDate ?? null),
+    recurrence: parseRecurrence(body.recurrence ?? null),
+  };
+  if (task.recurrence && !task.dueDate) {
+    throw new ApiError(400, "INVALID_FIELD", "A recurring issue requires 'dueDate'");
+  }
+  return task;
+}
+
+// Local and cloud entry points retain their existing validation order and errors.
+function assertTaskPatchBody(body) {
+  assertPlainObject(body);
+  assertAllowedKeys(body, new Set([
+    "version", "projectId", "title", "description", "status", "priority", "labels", "threadId", "threadBinding",
+    "assigneeTarget", "developmentContext", "startDate", "dueDate", "recurrence",
+  ]));
+}
+
+function parseTaskPatchChanges(body, parseDevelopmentContext) {
+  const changes = {};
+  if (body.projectId !== undefined) changes.projectId = validateProjectId(body.projectId);
+  if (body.title !== undefined) changes.title = stringField(body.title, "title", { required: true, maxLength: 240 });
+  if (body.description !== undefined) changes.description = stringField(body.description, "description", { maxLength: 100_000 });
+  if (body.status !== undefined) changes.status = parseStatus(body.status);
+  if (body.priority !== undefined) changes.priority = parsePriority(body.priority);
+  if (body.labels !== undefined) changes.labels = parseLabels(body.labels);
+  if (body.developmentContext !== undefined) changes.developmentContext = parseDevelopmentContext(body.developmentContext);
+  if (body.startDate !== undefined) changes.startDate = parseDueDate(body.startDate, "startDate");
+  if (body.dueDate !== undefined) changes.dueDate = parseDueDate(body.dueDate);
+  if (body.recurrence !== undefined) changes.recurrence = parseRecurrence(body.recurrence);
+  return changes;
+}
+
+function assertTaskPatchFields(changes, assigneeTarget) {
+  if (Object.keys(changes).length === 0 && assigneeTarget === undefined) {
+    throw new ApiError(400, "INVALID_BODY", "PATCH requires at least one task field");
+  }
+}
+
+export function parseTaskPatch(body, parseDevelopmentContext) {
+  assertTaskPatchBody(body);
+  const version = parseVersion(body.version);
+  const threadId = parseThreadId(body.threadId);
+  const threadBinding = parseThreadBinding(body.threadBinding);
+  const assigneeTarget = parseAssigneeTarget(body.assigneeTarget);
+  const changes = parseTaskPatchChanges(body, parseDevelopmentContext);
+  if (changes.recurrence && body.dueDate === null) {
+    throw new ApiError(400, "INVALID_FIELD", "A recurring issue requires 'dueDate'");
+  }
+  assertTaskPatchFields(changes, assigneeTarget);
+  return { version, changes, threadId, threadBinding, assigneeTarget };
+}
+
+export function parseCloudTaskPatch(body, parseDevelopmentContext) {
+  assertTaskPatchBody(body);
+  const changes = parseTaskPatchChanges(body, parseDevelopmentContext);
+  const assigneeTarget = parseAssigneeTarget(body.assigneeTarget);
+  assertTaskPatchFields(changes, assigneeTarget);
+  return {
+    version: parseVersion(body.version),
+    changes,
+    threadId: parseThreadId(body.threadId),
+    threadBinding: parseThreadBinding(body.threadBinding),
+    assigneeTarget,
+  };
+}
+
+function assertTaskQueryParameters(searchParams, allowed, repeatedCode, cloud = false) {
+  for (const key of searchParams.keys()) {
+    if (!allowed.has(key)) {
+      throw new ApiError(400, "UNKNOWN_QUERY_PARAMETER", cloud
+        ? `Unknown query parameter: ${key}`
+        : `Unknown query parameter '${key}'`);
+    }
+    const count = searchParams.getAll(key).length;
+    if (cloud ? count > 1 : count !== 1) {
+      throw new ApiError(400, repeatedCode, cloud
+        ? `'${key}' cannot be repeated`
+        : `Query parameter '${key}' cannot be repeated`);
+    }
+  }
+}
+
+function taskFilterValues(searchParams) {
+  return {
+    projectId: searchParams.get("projectId"),
+    status: searchParams.get("status"),
+    archived: searchParams.get("archived") ?? "false",
+  };
+}
+
+export function parseTaskFilters(searchParams) {
+  assertTaskQueryParameters(
+    searchParams, new Set(["projectId", "status", "archived"]), "INVALID_QUERY_PARAMETER",
+  );
+
+  const { projectId: projectIdValue, status: statusValue, archived } = taskFilterValues(searchParams);
+  if (statusValue !== null && !isTaskStatus(statusValue)) {
+    throw new ApiError(400, "INVALID_QUERY_PARAMETER", "Invalid task status");
+  }
+  if (!new Set(["true", "false", "all"]).has(archived)) {
+    throw new ApiError(400, "INVALID_QUERY_PARAMETER", "'archived' must be true, false, or all");
+  }
+  const projectId = projectIdValue === null ? undefined : validateProjectId(projectIdValue);
+  return { projectId, status: statusValue ?? undefined, archived };
+}
+
+export function parseCloudTaskFilters(searchParams) {
+  assertTaskQueryParameters(
+    searchParams, new Set(["projectId", "status", "archived"]), "INVALID_QUERY_PARAMETER", true,
+  );
+  const { projectId, status, archived } = taskFilterValues(searchParams);
+  if (projectId !== null) validateProjectId(projectId);
+  if (status !== null) parseStatus(status);
+  if (!["false", "true", "all"].includes(archived)) {
+    throw new ApiError(
+      400,
+      "INVALID_QUERY_PARAMETER",
+      "'archived' must be false, true, or all",
+    );
+  }
+  return { projectId, status, archived };
+}
+
+function taskTreeQueryValues(searchParams) {
+  const direction = searchParams.get("direction");
+  if (direction !== "descendants" && direction !== "ancestors") {
+    throw new ApiError(400, "INVALID_TREE_QUERY", "'direction' must be descendants or ancestors");
+  }
+  const rawDepth = searchParams.get("depth");
+  const depth = Number(rawDepth);
+  if (!/^\d+$/.test(rawDepth ?? "") || !Number.isSafeInteger(depth) || depth < 1 || depth > 25) {
+    throw new ApiError(400, "INVALID_TREE_QUERY", "'depth' must be an integer from 1 to 25");
+  }
+  return { direction, depth };
+}
+
+export function parseTaskTreeQuery(searchParams) {
+  assertTaskQueryParameters(searchParams, new Set(["direction", "depth"]), "INVALID_TREE_QUERY");
+  return taskTreeQueryValues(searchParams);
+}
+
+export function parseCloudTaskTreeQuery(searchParams) {
+  assertTaskQueryParameters(searchParams, new Set(["direction", "depth"]), "INVALID_TREE_QUERY", true);
+  return taskTreeQueryValues(searchParams);
+}
+
+function projectReadmeContent(value) {
+  const content = value ?? "";
+  if (typeof content !== "string") {
+    throw new ApiError(400, "INVALID_FIELD", "'content' must be a string");
+  }
+  if (content.length > 500_000) {
+    throw new ApiError(400, "INVALID_FIELD", "'content' cannot exceed 500000 characters");
+  }
+  return content;
+}
+
+export function parseProjectReadmeSave(body) {
+  assertPlainObject(body);
+  assertAllowedKeys(body, new Set(["content", "version"]));
+  const content = projectReadmeContent(body.content);
+  const version = body.version === undefined ? undefined : parseVersion(body.version, { allowZero: true });
+  return { content, version };
+}
+
+export function parseCloudProjectReadmeSave(body) {
+  assertPlainObject(body);
+  assertAllowedKeys(body, new Set(["version", "content"]));
+  const version = body.version === undefined ? undefined : parseVersion(body.version, { allowZero: true });
+  const content = projectReadmeContent(body.content);
+  return { content, version };
+}

package/vendor/codex-taskboard/shared/task-records.mjs

@@ -0,0 +1,199 @@
+export function commentConversationTitle(body) {
+  const firstLine = String(body ?? "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find(Boolean);
+  if (!firstLine) return "评论";
+  const compact = firstLine.replace(/\s+/g, " ");
+  return compact.length > 80 ? `${compact.slice(0, 77)}…` : compact;
+}
+
+export function threadBindingFromRow(row) {
+  if (
+    !row.thread_id
+    || !row.thread_codex_project_id
+    || !row.thread_codex_project_kind
+    || !row.thread_codex_host_id
+    || !row.thread_workspace_path
+  ) return null;
+  return {
+    threadId: row.thread_id,
+    codexProjectId: row.thread_codex_project_id,
+    codexProjectKind: row.thread_codex_project_kind,
+    codexHostId: row.thread_codex_host_id,
+    workspacePath: row.thread_workspace_path,
+  };
+}
+
+export function legacyLocalThreadIdFromRow(row) {
+  if (!row.thread_id) return null;
+  return [
+    row.thread_codex_project_id,
+    row.thread_codex_project_kind,
+    row.thread_codex_host_id,
+    row.thread_workspace_path,
+  ].every((value) => value == null)
+    ? row.thread_id
+    : null;
+}
+
+export function storedThreadBinding(threadBinding, threadId) {
+  if (threadBinding === undefined && (threadId === undefined || threadId === null)) return undefined;
+  const binding = threadBinding === undefined ? { threadId } : threadBinding;
+  return [
+    binding?.threadId ?? null,
+    binding?.codexProjectId ?? null,
+    binding?.codexProjectKind ?? null,
+    binding?.codexHostId ?? null,
+    binding?.workspacePath ?? null,
+  ];
+}
+
+export function attachTaskActivity(task, comments, activities, previewImage = null) {
+  const orderedComments = [...comments].sort((left, right) => (
+    left.id.localeCompare(right.id)
+  ));
+  const orderedActivities = [...activities].sort((left, right) => (
+    left.id.localeCompare(right.id)
+  ));
+  const participants = [];
+  const participantIds = new Set();
+  const addParticipant = (actor) => {
+    const key = `${actor.type}:${actor.id}`;
+    if (participantIds.has(key)) return;
+    participantIds.add(key);
+    participants.push(actor);
+  };
+  addParticipant({
+    type: task.creatorType,
+    id: task.creatorId,
+    name: task.creatorName,
+    avatarUrl: task.creatorAvatarUrl,
+  });
+  addParticipant(task.assignee);
+  for (const comment of orderedComments) {
+    addParticipant({
+      type: comment.author_type,
+      id: comment.author_id,
+      name: comment.author_name,
+      avatarUrl: comment.author_avatar_url,
+    });
+  }
+  for (const activity of orderedActivities) {
+    addParticipant({
+      type: activity.actor_type,
+      id: activity.actor_id,
+      name: activity.actor_name,
+      avatarUrl: activity.actor_avatar_url,
+    });
+  }
+  const conversationRefs = [];
+  if (task.threadBinding) {
+    conversationRefs.push({
+      ...task.threadBinding,
+      source: "task",
+      sourceId: task.id,
+      title: task.title,
+      updatedAt: task.updatedAt,
+    });
+  } else if (task.legacyLocalThreadId) {
+    conversationRefs.push({
+      threadId: task.legacyLocalThreadId,
+      legacyLocal: true,
+      source: "task",
+      sourceId: task.id,
+      title: task.title,
+      updatedAt: task.updatedAt,
+    });
+  }
+  for (const comment of orderedComments) {
+    const threadBinding = threadBindingFromRow(comment);
+    const legacyLocalThreadId = legacyLocalThreadIdFromRow(comment);
+    if (threadBinding || legacyLocalThreadId) {
+      conversationRefs.push({
+        ...(threadBinding ?? { threadId: legacyLocalThreadId, legacyLocal: true }),
+        source: "comment",
+        sourceId: comment.id,
+        title: commentConversationTitle(comment.body),
+        updatedAt: comment.updated_at,
+      });
+    }
+  }
+
+  task.conversationRefs = conversationRefs;
+  task.participants = participants;
+  task.previewImage = previewImage;
+  task.activityKey = JSON.stringify({
+    version: 1,
+    task: [task.id, task.version, task.updatedAt],
+    comments: orderedComments.map((comment) => [comment.id, comment.version, comment.updated_at]),
+    changes: orderedActivities.map((activity) => [activity.id, activity.created_at]),
+  });
+  task.activityUpdatedAt = [...orderedComments, ...orderedActivities].reduce(
+    (latest, activity) => {
+      const updatedAt = activity.updated_at ?? activity.created_at;
+      return updatedAt > latest ? updatedAt : latest;
+    },
+    task.updatedAt,
+  );
+  return task;
+}
+
+export function taskActivityFromRow(row) {
+  return {
+    id: row.id,
+    taskId: row.task_id,
+    actorType: row.actor_type,
+    actorId: row.actor_id,
+    actorName: row.actor_name,
+    actorAvatarUrl: row.actor_avatar_url,
+    changes: JSON.parse(row.changes),
+    createdAt: row.created_at,
+  };
+}
+
+export function taskFieldChanges(task, changes) {
+  return Object.entries(changes).flatMap(([field, after]) => {
+    const before = task[field];
+    return JSON.stringify(before) === JSON.stringify(after)
+      ? []
+      : [{ field, before, after }];
+  });
+}
+
+export function taskTreeNode(row, parentId, depth, path) {
+  return {
+    id: row.id,
+    parentId,
+    depth,
+    path,
+    summary: {
+      identifier: row.identifier,
+      title: row.title,
+      status: row.status,
+      priority: row.priority,
+      archivedAt: row.archived_at,
+    },
+  };
+}
+
+export function projectReadmeAttachmentFromRow(row) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    kind: "inline",
+    filename: row.filename,
+    contentType: row.content_type,
+    size: row.size,
+    createdAt: row.created_at,
+  };
+}
+
+export function projectPrefix(project) {
+  const idPrefix = project.id.toUpperCase().replace(/[^A-Z0-9]+/g, "").slice(0, 12) || "TASK";
+  const existingPrefix = project.first_identifier?.replace(/-\d+$/, "");
+  if (existingPrefix && /^[A-Z0-9]+$/i.test(existingPrefix) && existingPrefix !== idPrefix) return existingPrefix;
+  if (idPrefix.length <= 5) return idPrefix;
+  const namePrefix = project.name.toUpperCase().replace(/[^A-Z0-9]+/g, "").slice(0, 3);
+  return namePrefix || idPrefix.slice(0, 3);
+}

package/vendor/codex-taskboard/shared/task-relations.mjs

@@ -0,0 +1,55 @@
+// Select both endpoints once per ID batch; the outer order also interleaves
+// incoming and outgoing "related" edges in the original task order.
+export function taskRelationsQuery(placeholders) {
+  return `
+    WITH selected_tasks AS (
+      SELECT id FROM tasks WHERE id IN (${placeholders})
+    ), relation_targets AS (
+      SELECT
+        selected_tasks.id AS task_id,
+        task_relations.target_task_id AS related_task_id,
+        CASE task_relations.relation_type
+          WHEN 'parent' THEN 'subIssues'
+          WHEN 'blocks' THEN 'blocks'
+          WHEN 'related' THEN 'related'
+        END AS relation_field
+      FROM selected_tasks
+      JOIN task_relations ON task_relations.source_task_id = selected_tasks.id
+      UNION ALL
+      SELECT
+        selected_tasks.id AS task_id,
+        task_relations.source_task_id AS related_task_id,
+        CASE task_relations.relation_type
+          WHEN 'parent' THEN 'parent'
+          WHEN 'blocks' THEN 'blockedBy'
+          WHEN 'related' THEN 'related'
+        END AS relation_field
+      FROM selected_tasks
+      JOIN task_relations ON task_relations.target_task_id = selected_tasks.id
+    )
+    SELECT tasks.*, relation_targets.task_id AS relation_task_id, relation_targets.relation_field
+    FROM relation_targets
+    JOIN tasks ON tasks.id = relation_targets.related_task_id
+    ORDER BY tasks.sort_order, tasks.created_at, tasks.id
+  `;
+}
+
+export function taskRelationsFromRows(taskIds, rows, summarizeTask) {
+  const relationsByTask = new Map(taskIds.map((taskId) => [taskId, {
+    parent: null,
+    subIssues: [],
+    blockedBy: [],
+    blocks: [],
+    related: [],
+  }]));
+  for (const row of rows) {
+    const relations = relationsByTask.get(row.relation_task_id);
+    const summary = summarizeTask(row);
+    if (row.relation_field === "parent") {
+      relations.parent = summary;
+    } else {
+      relations[row.relation_field].push(summary);
+    }
+  }
+  return relationsByTask;
+}