@bryanhu/codexly 0.18.0 → 0.20.0

package/dist/chunk-B2673ODM.js

@@ -0,0 +1,260 @@
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// packages/core/src/agent-provider.ts
+var WorkbenchPetProviderError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "WorkbenchPetProviderError";
+  }
+  code;
+};
+var PendingRequestResolutionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PendingRequestResolutionError";
+  }
+  code;
+};
+
+// packages/core/src/task-submission.ts
+var TaskSubmissionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+async function submitTask(repository, projectId, key, fingerprint, input, ports) {
+  let record = await repository.readSubmission(projectId, key);
+  if (record !== void 0 && record.fingerprint !== fingerprint) {
+    throw new TaskSubmissionError(
+      "IDEMPOTENCY_CONFLICT",
+      "Submission key was used with another request"
+    );
+  }
+  if (record?.stage === "creating" || record?.stage === "starting") {
+    throw new TaskSubmissionError(
+      "SUBMISSION_OUTCOME_UNKNOWN",
+      "Submission outcome is unknown; inspect the task before submitting again"
+    );
+  }
+  if (record?.stage === "completed" && record.result !== void 0) return record.result;
+  const save = async (next) => {
+    await repository.writeSubmission(projectId, key, next);
+    record = next;
+  };
+  if (record?.stage !== "started") {
+    await ports.validate();
+    if (input.taskId === void 0 && record?.task === void 0) {
+      await save({ fingerprint, stage: "creating" });
+      const task2 = await ports.createTask();
+      await save({ fingerprint, stage: "ready", task: task2 });
+    }
+    const task = record?.task;
+    const taskId = input.taskId ?? task?.id;
+    if (taskId === void 0) throw new Error("Submission task is unavailable");
+    const attachmentIds = await ports.prepare(taskId);
+    await save({
+      fingerprint,
+      stage: "starting",
+      attachmentIds,
+      ...task === void 0 ? {} : { task }
+    });
+    const result2 = {
+      ...await ports.execute(taskId),
+      ...task === void 0 ? {} : { createdTask: task }
+    };
+    await save({
+      fingerprint,
+      stage: "started",
+      result: result2,
+      attachmentIds,
+      ...task === void 0 ? {} : { task }
+    });
+  }
+  const result = record?.result;
+  if (result === void 0) throw new Error("Submission result is unavailable");
+  await ports.complete(result, record?.attachmentIds ?? []);
+  await save({ ...record, fingerprint, stage: "completed", result });
+  return result;
+}
+
+// packages/core/src/project-todo.ts
+var ProjectTodoError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+async function saveProjectTodo(repository, projectId, id, draft, expectedVersion, now, prepareAttachments) {
+  const existing = (await repository.listProjectTodos(projectId)).find((todo2) => todo2.id === id);
+  if (expectedVersion !== null && existing === void 0)
+    throw new ProjectTodoError("PROJECT_TODO_NOT_FOUND", "Project todo not found");
+  if ((existing?.version ?? null) !== expectedVersion)
+    throw new ProjectTodoError("PROJECT_TODO_CHANGED", "Project todo changed");
+  const todo = {
+    id,
+    projectId,
+    draft,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    version: (existing?.version ?? 0) + 1
+  };
+  const attachments = await prepareAttachments();
+  await repository.saveProjectTodo(todo, expectedVersion, attachments);
+  return todo;
+}
+
+// packages/core/src/async-question.ts
+function collectQuestionGroups(turns, identify) {
+  return turns.flatMap((turn) => {
+    const occurrences = /* @__PURE__ */ new Map();
+    return turn.items.flatMap((item) => {
+      if (item.type !== "message" || item.role !== "assistant" || !item.questions?.length)
+        return [];
+      const questions = item.questions.map(({ title, options }) => ({ title, options }));
+      const signature = JSON.stringify(questions);
+      const occurrence = occurrences.get(signature) ?? 0;
+      occurrences.set(signature, occurrence + 1);
+      return [
+        {
+          id: identify(JSON.stringify([turn.id, signature, occurrence])),
+          turnId: turn.id,
+          questions,
+          createdAt: turn.startedAt ?? "1970-01-01T00:00:00.000Z",
+          status: "pending"
+        }
+      ];
+    });
+  });
+}
+function formatQuestionAnswers(questions, answers) {
+  if (answers.length !== questions.length || answers.some((answer) => answer.trim().length === 0 || answer.length > 4e3))
+    throw new Error("Invalid question answers");
+  const text = questions.map((question, index) => `${question.title}
+${answers[index]?.trim() ?? ""}`).join("\n\n");
+  if (text.length > 1e5) throw new Error("Invalid question answers");
+  return text;
+}
+
+// packages/core/src/archived-task-deletion.ts
+async function deleteArchivedTasks(provider, scopeId) {
+  const ids = /* @__PURE__ */ new Set();
+  const cursors = /* @__PURE__ */ new Set();
+  let cursor;
+  for (; ; ) {
+    if (cursors.size >= 1e3) throw new Error("Archived task pagination exceeds the page limit");
+    const page = await provider.listTasks({
+      archived: true,
+      limit: 100,
+      ...cursor === void 0 ? {} : { cursor }
+    });
+    for (const task of page.data) {
+      if (task.projectId !== scopeId) throw new Error("Archived task listing crossed its scope");
+      ids.add(task.id);
+      if (ids.size > 1e4) throw new Error("Archived task deletion exceeds the 10000 task limit");
+    }
+    if (page.nextCursor === null) break;
+    if (cursors.has(page.nextCursor))
+      throw new Error("Archived task pagination returned a repeated cursor");
+    cursors.add(page.nextCursor);
+    cursor = page.nextCursor;
+  }
+  const tasks = [...ids];
+  let deletedCount = 0;
+  let failedCount = 0;
+  for (let index = 0; index < tasks.length; index += 4) {
+    const results = await Promise.allSettled(
+      tasks.slice(index, index + 4).map(async (id) => {
+        const task = await provider.readTask(id);
+        if (task?.projectId !== scopeId) throw new Error("Archived task is no longer in scope");
+        await provider.deleteTask(id);
+      })
+    );
+    for (const result of results) {
+      if (result.status === "fulfilled") deletedCount++;
+      else failedCount++;
+    }
+  }
+  return { deletedCount, failedCount };
+}
+
+// packages/core/src/task-catalog.ts
+async function listTaskCatalog(provider, scopeId, options = {}) {
+  const tasks = /* @__PURE__ */ new Map();
+  const cursors = /* @__PURE__ */ new Set();
+  let cursor;
+  for (; ; ) {
+    if (cursors.size >= 1e3) throw new Error("Task catalog pagination exceeds the page limit");
+    const page = await provider.listTasks({
+      limit: 100,
+      ...options.pinned === true ? { pinnedOnly: true } : {},
+      ...cursor === void 0 ? {} : { cursor }
+    });
+    for (const task of page.data) {
+      if (task.projectId !== scopeId) throw new Error("Task catalog crossed its scope");
+      if (!tasks.has(task.id)) tasks.set(task.id, task);
+      if (tasks.size > 1e4) throw new Error("Task catalog exceeds the 10000 task limit");
+    }
+    if (page.nextCursor === null) return { data: [...tasks.values()] };
+    if (cursors.has(page.nextCursor)) throw new Error("Task catalog returned a repeated cursor");
+    cursors.add(page.nextCursor);
+    cursor = page.nextCursor;
+  }
+}
+
+// packages/core/src/completed-task-query.ts
+var CompletedTasksQueryError = class extends Error {
+};
+async function queryCompletedTasks(resolve, input) {
+  const { projectIds, cursor } = input;
+  const scopes = new Set(projectIds);
+  if (scopes.size !== projectIds.length || scopes.size > 100)
+    throw new CompletedTasksQueryError("Invalid completed task scopes");
+  if (cursor !== void 0 && (Object.keys(cursor).length !== scopes.size || Object.keys(cursor).some((id) => !scopes.has(id)))) {
+    throw new CompletedTasksQueryError("Completed task cursor does not match its scopes");
+  }
+  const active = projectIds.filter((id) => cursor === void 0 || cursor[id] !== null);
+  const limit = Math.max(1, Math.ceil(10 / Math.max(1, active.length)));
+  const cursors = Object.fromEntries(
+    projectIds.map((id) => [id, null])
+  );
+  const tasks = /* @__PURE__ */ new Map();
+  for (let index = 0; index < active.length; index += 4) {
+    const pages = await Promise.all(
+      active.slice(index, index + 4).map(async (id) => {
+        const provider = await resolve(id);
+        const previous = cursor?.[id];
+        const page = await provider.listTasks({
+          completed: true,
+          limit,
+          ...typeof previous === "string" ? { cursor: previous } : {}
+        });
+        if (page.data.length > limit) throw new Error("Completed task page exceeds its limit");
+        if (page.nextCursor !== null && page.nextCursor === previous)
+          throw new Error("Completed task page returned a repeated cursor");
+        for (const task of page.data)
+          if (task.projectId !== id) throw new Error("Completed task page crossed its scope");
+        return { id, page };
+      })
+    );
+    for (const { id, page } of pages) {
+      cursors[id] = page.nextCursor;
+      for (const task of page.data) {
+        const key = JSON.stringify([id, task.id]);
+        if (!tasks.has(key)) tasks.set(key, task);
+      }
+    }
+  }
+  return {
+    data: [...tasks.values()].sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt)),
+    nextCursor: Object.values(cursors).some((value) => value !== null) ? cursors : null
+  };
+}
+
+export { CompletedTasksQueryError, PendingRequestResolutionError, ProjectTodoError, TaskSubmissionError, WorkbenchPetProviderError, collectQuestionGroups, deleteArchivedTasks, formatQuestionAnswers, listTaskCatalog, queryCompletedTasks, saveProjectTodo, submitTask };

package/dist/chunk-GT7XTSEG.js

@@ -0,0 +1,56 @@
+import { createRequire } from 'node:module';
+import { __export } from './chunk-K6J42667.js';
+
+createRequire(import.meta.url);
+
+// packages/protocol/src/scheduled-task-wall-time.ts
+var scheduled_task_wall_time_exports = {};
+__export(scheduled_task_wall_time_exports, {
+  wallTimeToUnix: () => wallTimeToUnix,
+  zonedDateTime: () => zonedDateTime
+});
+var cachedTimezone = "";
+var cachedFormatter;
+function zonedDateTime(unixMs, timezone) {
+  if (cachedTimezone !== timezone) {
+    cachedFormatter = new Intl.DateTimeFormat("sv-SE", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23"
+    });
+    cachedTimezone = timezone;
+  }
+  const parts = cachedFormatter.formatToParts(unixMs);
+  const part = (type) => {
+    const value = parts.find((item) => item.type === type)?.value;
+    if (value === void 0) throw new Error(`Missing date part: ${type}`);
+    return value;
+  };
+  return `${part("year")}-${part("month")}-${part("day")}T${part("hour")}:${part("minute")}:${part("second")}`;
+}
+function wallTimeToUnix(value, timezone) {
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?$/u.test(value)) return void 0;
+  const normalized = value.length === 16 ? `${value}:00` : value;
+  const wall = Date.parse(`${normalized}Z`);
+  if (!Number.isFinite(wall) || new Date(wall).toISOString().slice(0, 19) !== normalized)
+    return void 0;
+  if (timezone === "UTC") return wall;
+  try {
+    let candidate = wall;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      const formatted = zonedDateTime(candidate, timezone);
+      if (formatted === normalized) return candidate;
+      candidate += wall - Date.parse(`${formatted}Z`);
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+
+export { scheduled_task_wall_time_exports, wallTimeToUnix, zonedDateTime };