@treeseed/core 0.4.9 → 0.4.11

package/dist/services/remote-runner.d.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { AgentSdk } from '@treeseed/sdk';
+export declare function resolveRemoteRunnerConfig(): {
+    marketBaseUrl: string;
+    projectId: string;
+    runnerToken: string;
+    runnerId: string;
+    batchSize: number;
+    pollIntervalMs: number;
+};
+export declare function runRemoteRunnerCycle(options?: {
+    sdk?: AgentSdk;
+    config?: ReturnType<typeof resolveRemoteRunnerConfig>;
+    fetchImpl?: typeof fetch;
+}): Promise<{
+    ok: boolean;
+    processed: number;
+    idle: boolean;
+    reason: string;
+} | {
+    ok: boolean;
+    processed: number;
+    idle?: undefined;
+    reason?: undefined;
+}>;
+export declare function startRemoteRunnerLoop(options?: {
+    sdk?: AgentSdk;
+    config?: ReturnType<typeof resolveRemoteRunnerConfig>;
+    fetchImpl?: typeof fetch;
+}): Promise<void>;

package/dist/services/remote-runner.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { AgentSdk, RemoteTreeseedClient, RemoteTreeseedRunnerClient } from "@treeseed/sdk";
+import { createServiceSdk } from "./common.js";
+function integerFromEnv(name, fallback) {
+  const value = process.env[name];
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function envValue(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : "";
+}
+function resolveRemoteRunnerConfig() {
+  return {
+    marketBaseUrl: envValue("TREESEED_MARKET_API_BASE_URL") || envValue("TREESEED_API_BASE_URL"),
+    projectId: envValue("TREESEED_PROJECT_ID") || "treeseed-market",
+    runnerToken: envValue("TREESEED_PROJECT_RUNNER_TOKEN"),
+    runnerId: envValue("TREESEED_REMOTE_RUNNER_ID") || `remote-runner-${process.pid}`,
+    batchSize: integerFromEnv("TREESEED_REMOTE_RUNNER_BATCH_SIZE", 1),
+    pollIntervalMs: integerFromEnv("TREESEED_REMOTE_RUNNER_POLL_INTERVAL_MS", 5e3)
+  };
+}
+function createRunnerClient(config, fetchImpl) {
+  if (!config.marketBaseUrl || !config.runnerToken) {
+    if (process.env.TREESEED_LOCAL_DEV_MODE?.trim()) {
+      return null;
+    }
+    throw new Error(
+      "Remote runner requires TREESEED_MARKET_API_BASE_URL (or TREESEED_API_BASE_URL) and TREESEED_PROJECT_RUNNER_TOKEN."
+    );
+  }
+  return new RemoteTreeseedRunnerClient(new RemoteTreeseedClient({
+    hosts: [{ id: "market", baseUrl: config.marketBaseUrl }],
+    activeHostId: "market",
+    auth: {
+      accessToken: config.runnerToken
+    }
+  }, {
+    fetchImpl
+  }));
+}
+async function runRemoteRunnerCycle(options = {}) {
+  const config = options.config ?? resolveRemoteRunnerConfig();
+  const sdk = options.sdk ?? createServiceSdk();
+  const runner = createRunnerClient(config, options.fetchImpl);
+  if (!runner) {
+    return { ok: true, processed: 0, idle: true, reason: "registration_unconfigured" };
+  }
+  const pulled = await runner.pull(config.projectId, {
+    limit: config.batchSize,
+    runnerId: config.runnerId
+  });
+  if (pulled.payload.length === 0) {
+    return { ok: true, processed: 0 };
+  }
+  let processed = 0;
+  for (const job of pulled.payload) {
+    try {
+      await runner.progress(job.id, {
+        summary: `Running ${job.namespace}:${job.operation}`,
+        data: {
+          runnerId: config.runnerId,
+          status: "running"
+        }
+      });
+      const result = await sdk.dispatch({
+        namespace: job.namespace,
+        operation: job.operation,
+        input: job.input ?? {},
+        preferredMode: "prefer_local"
+      });
+      await runner.complete(job.id, {
+        output: result.mode === "inline" ? result.payload : result
+      });
+      processed += 1;
+    } catch (error) {
+      await runner.fail(job.id, {
+        code: "runner_execution_failed",
+        message: error instanceof Error ? error.message : String(error)
+      }).catch(() => null);
+    }
+  }
+  return { ok: true, processed };
+}
+async function startRemoteRunnerLoop(options = {}) {
+  const config = options.config ?? resolveRemoteRunnerConfig();
+  for (; ; ) {
+    try {
+      await runRemoteRunnerCycle({
+        ...options,
+        config
+      });
+    } catch (error) {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, config.pollIntervalMs));
+  }
+}
+const currentFile = fileURLToPath(import.meta.url);
+const entryFile = process.argv[1] ?? "";
+if (entryFile === currentFile) {
+  await startRemoteRunnerLoop();
+}
+export {
+  resolveRemoteRunnerConfig,
+  runRemoteRunnerCycle,
+  startRemoteRunnerLoop
+};

package/dist/services/workday-content.d.ts

@@ -0,0 +1,53 @@
+import type { PrioritySnapshot, ScaleDecision, WorkerPoolScaleResult } from '@treeseed/sdk';
+type JsonRecord = Record<string, unknown>;
+export interface WorkdayContentTaskSummary {
+    id: string;
+    agentId?: string;
+    type?: string;
+    state?: string;
+    priority?: number;
+    idempotencyKey?: string;
+    createdAt?: string | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    lastErrorCode?: string | null;
+    lastErrorMessage?: string | null;
+    lastEventKind?: string | null;
+    outputCount?: number;
+    changedFiles?: string[];
+}
+export interface WorkdayContentReleaseRecord {
+    id?: string;
+    deploymentKind: string;
+    status: string;
+    releaseTag?: string | null;
+    commitSha?: string | null;
+    sourceRef?: string | null;
+    startedAt?: string | null;
+    finishedAt?: string | null;
+    createdAt?: string | null;
+}
+export interface WorkdayContentSnapshotInput {
+    repoRoot: string;
+    projectId: string;
+    teamId: string;
+    environment: string;
+    workDay: JsonRecord;
+    summary: JsonRecord;
+    prioritySnapshot: PrioritySnapshot | null;
+    scaleDecision: ScaleDecision;
+    scaleResult: WorkerPoolScaleResult;
+    tasks: WorkdayContentTaskSummary[];
+    changedFiles: string[];
+    releases: WorkdayContentReleaseRecord[];
+    generatedAt: string;
+}
+export interface WorkdayContentSnapshotResult {
+    filePath: string;
+    relativePath: string;
+    slug: string;
+    reportVersion: string;
+    title: string;
+}
+export declare function writeWorkdayContentSnapshot(input: WorkdayContentSnapshotInput): WorkdayContentSnapshotResult;
+export {};

package/dist/services/workday-content.js

@@ -0,0 +1,190 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { stringify as stringifyYaml } from "yaml";
+function stableHash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function sanitizeSegment(value, fallback) {
+  const normalized = value.trim().replaceAll(/[\\/]+/g, "-").replaceAll(/[^a-zA-Z0-9._-]+/g, "-").replaceAll(/-+/g, "-").replaceAll(/^-|-$/g, "");
+  return normalized || fallback;
+}
+function compactTimestamp(value) {
+  return value.replaceAll(/[-:]/g, "").replace(/\.\d{3}Z$/u, "Z");
+}
+function toIsoDate(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const parsed = new Date(value);
+  return Number.isFinite(parsed.valueOf()) ? parsed.toISOString() : null;
+}
+function bodySummary(summary) {
+  return typeof summary.summary === "string" && summary.summary.trim() ? summary.summary.trim() : `Completed ${Number(summary.completedTasks ?? 0)} tasks, with ${Number(summary.failedTasks ?? 0)} failures and ${Number(summary.remainingTaskCredits ?? 0)} remaining task credits.`;
+}
+function renderTasks(tasks) {
+  if (tasks.length === 0) {
+    return "- No tasks were recorded.\n";
+  }
+  return tasks.map((task) => {
+    const suffix = [
+      task.state ? `state: ${task.state}` : null,
+      task.agentId ? `agent: ${task.agentId}` : null,
+      Number.isFinite(task.priority) ? `priority: ${task.priority}` : null,
+      task.lastEventKind ? `last event: ${task.lastEventKind}` : null,
+      task.outputCount ? `outputs: ${task.outputCount}` : null
+    ].filter(Boolean).join(", ");
+    return `- \`${task.id}\` ${task.type ?? "task"}${suffix ? ` (${suffix})` : ""}`;
+  }).join("\n") + "\n";
+}
+function renderChangedFiles(changedFiles) {
+  if (changedFiles.length === 0) {
+    return "- No changed files were reported by task outputs.\n";
+  }
+  return changedFiles.map((filePath) => `- \`${filePath}\``).join("\n") + "\n";
+}
+function renderReleases(releases) {
+  if (releases.length === 0) {
+    return "- No releases or deployments were recorded during this workday.\n";
+  }
+  return releases.map((release) => {
+    const label = release.releaseTag || release.commitSha || release.id || release.deploymentKind;
+    const details = [release.deploymentKind, release.status, release.sourceRef].filter(Boolean).join(", ");
+    return `- \`${label}\`${details ? ` (${details})` : ""}`;
+  }).join("\n") + "\n";
+}
+function renderPriorityItems(snapshot) {
+  if (!snapshot?.items?.length) {
+    return "- No priority snapshot items were captured.\n";
+  }
+  return snapshot.items.map((item) => {
+    const details = [
+      item.model,
+      Number.isFinite(item.priority) ? `priority: ${item.priority}` : null,
+      Number.isFinite(item.estimatedCredits) ? `credits: ${item.estimatedCredits}` : null
+    ].filter(Boolean).join(", ");
+    return `- \`${item.id}\`${item.title ? ` ${item.title}` : ""}${details ? ` (${details})` : ""}`;
+  }).join("\n") + "\n";
+}
+function buildMarkdownBody(input) {
+  const summaryText = bodySummary(input.summary);
+  return [
+    summaryText,
+    "",
+    "## Budget",
+    "",
+    `- Daily task-credit budget: ${Number(input.summary.dailyTaskCreditBudget ?? 0)}`,
+    `- Used task credits: ${Number(input.summary.usedTaskCredits ?? 0)}`,
+    `- Remaining task credits: ${Number(input.summary.remainingTaskCredits ?? 0)}`,
+    `- Credit ledger entries: ${Number(input.summary.creditLedgerEntries ?? 0)}`,
+    "",
+    "## Priority Plan",
+    "",
+    renderPriorityItems(input.prioritySnapshot).trimEnd(),
+    "",
+    "## Tasks",
+    "",
+    renderTasks(input.tasks).trimEnd(),
+    "",
+    "## Changed Files",
+    "",
+    renderChangedFiles(input.changedFiles).trimEnd(),
+    "",
+    "## Releases",
+    "",
+    renderReleases(input.releases).trimEnd(),
+    "",
+    "## Final Status",
+    "",
+    `- Workday state: ${String(input.workDay.state ?? "completed")}`,
+    `- Desired workers: ${Number(input.scaleDecision.desiredWorkers ?? 0)}`,
+    `- Queue depth at report: ${Number(input.scaleDecision.observedQueueDepth ?? 0)}`,
+    `- Active leases at report: ${Number(input.scaleDecision.observedActiveLeases ?? 0)}`,
+    `- Scale provider: ${input.scaleResult.provider}`,
+    ""
+  ].join("\n");
+}
+function writeWorkdayContentSnapshot(input) {
+  const outputRoot = resolve(input.repoRoot, "src/content/workdays");
+  mkdirSync(outputRoot, { recursive: true });
+  const workDayId = String(input.workDay.id ?? "workday");
+  const startedAt = toIsoDate(input.workDay.startedAt ?? input.workDay.started_at) ?? input.generatedAt;
+  const endedAt = toIsoDate(input.workDay.endedAt ?? input.workDay.ended_at);
+  const generatedAt = toIsoDate(input.generatedAt) ?? (/* @__PURE__ */ new Date()).toISOString();
+  const datePart = (startedAt || generatedAt).slice(0, 10);
+  const slugBase = `${datePart}/${sanitizeSegment(workDayId, "workday")}`;
+  const identityHash = stableHash(JSON.stringify({
+    workDayId,
+    generatedAt,
+    summary: input.summary,
+    changedFiles: input.changedFiles,
+    releases: input.releases
+  })).slice(0, 8);
+  const reportVersion = `${compactTimestamp(generatedAt)}-${identityHash}`;
+  const title = `Workday ${workDayId} Report ${generatedAt.slice(0, 10)}`;
+  const slug = `workdays/${slugBase}/${reportVersion}`;
+  const frontmatter = {
+    title,
+    slug,
+    workDayId,
+    reportVersion,
+    reportKind: "workday_summary",
+    projectId: input.projectId,
+    teamId: input.teamId,
+    environment: input.environment,
+    status: "live",
+    visibility: "team",
+    workdayState: String(input.workDay.state ?? "completed"),
+    startedAt,
+    endedAt,
+    generatedAt,
+    createdAt: generatedAt,
+    summary: bodySummary(input.summary),
+    dailyTaskCreditBudget: Number(input.summary.dailyTaskCreditBudget ?? 0),
+    usedTaskCredits: Number(input.summary.usedTaskCredits ?? 0),
+    remainingTaskCredits: Number(input.summary.remainingTaskCredits ?? 0),
+    creditLedgerEntries: Number(input.summary.creditLedgerEntries ?? 0),
+    prioritySnapshotId: input.prioritySnapshot?.id ?? null,
+    priorityItemCount: input.prioritySnapshot?.items.length ?? 0,
+    priorityItems: input.prioritySnapshot?.items ?? [],
+    totalTasks: Number(input.summary.totalTasks ?? input.tasks.length),
+    completedTasks: Number(input.summary.completedTasks ?? 0),
+    failedTasks: Number(input.summary.failedTasks ?? 0),
+    queuedTasks: Number(input.summary.queuedTasks ?? 0),
+    activeTasks: Number(input.summary.activeTasks ?? 0),
+    taskItems: input.tasks,
+    changedFiles: input.changedFiles,
+    releases: input.releases,
+    scaleDecision: input.scaleDecision,
+    scaleResult: input.scaleResult,
+    metadata: {
+      source: "manager",
+      projectId: input.projectId
+    }
+  };
+  const markdownBody = buildMarkdownBody(input);
+  let fileName = `${datePart}-${sanitizeSegment(workDayId, "workday")}--${reportVersion}.mdx`;
+  let filePath = resolve(outputRoot, fileName);
+  let duplicateCounter = 1;
+  while (existsSync(filePath)) {
+    fileName = `${datePart}-${sanitizeSegment(workDayId, "workday")}--${reportVersion}-${duplicateCounter}.mdx`;
+    filePath = resolve(outputRoot, fileName);
+    duplicateCounter += 1;
+  }
+  const document = `---
+${stringifyYaml(frontmatter).trimEnd()}
+---
+
+${markdownBody}`;
+  writeFileSync(filePath, document, "utf8");
+  return {
+    filePath,
+    relativePath: relative(input.repoRoot, filePath).replaceAll("\\", "/"),
+    slug,
+    reportVersion,
+    title
+  };
+}
+export {
+  writeWorkdayContentSnapshot
+};

package/dist/services/workday-report.d.ts

@@ -1,17 +1,175 @@
 #!/usr/bin/env node
 export declare function runWorkdayReport(): Promise<{
+    ok: boolean;
+    mode: "reconcile";
+    managerId: string;
+    projectId: string;
+    environment: "local" | "prod" | "staging";
+    insideWorkWindow: boolean;
+    workPolicy: import("@treeseed/sdk").WorkdayPolicy;
+    workDay: Record<string, unknown>;
+    prioritySnapshot: import("@treeseed/sdk").PrioritySnapshot;
+    seededTasks: {
+        [x: string]: unknown;
+    }[];
+    queuedCount: number;
+    activeLeases: number;
+    desiredWorkers: number;
+    scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+    workdaySummary: Record<string, unknown>;
+} | {
+    ok: boolean;
+    created: boolean;
+    workDay: Record<string, unknown>;
+    skipped?: undefined;
+    reason?: undefined;
+    prioritySnapshot?: undefined;
+} | {
+    ok: boolean;
+    created: boolean;
+    skipped: boolean;
+    reason: string;
+    workDay?: undefined;
+    prioritySnapshot?: undefined;
+} | {
+    ok: boolean;
+    created: boolean;
+    workDay: import("@treeseed/sdk").SdkWorkDayEntity;
+    prioritySnapshot: import("@treeseed/sdk").PrioritySnapshot;
+    skipped?: undefined;
+    reason?: undefined;
+} | {
+    ok: boolean;
+    skipped: boolean;
+    reason: string;
+    workDay?: undefined;
+    summary?: undefined;
+    scale?: undefined;
+} | {
+    ok: boolean;
+    workDay: import("@treeseed/sdk").SdkWorkDayEntity;
+    summary: {
+        contentSnapshot: {
+            relativePath: string;
+            slug: string;
+            reportVersion: string;
+            title: string;
+        };
+        projectId: string;
+        environment: "local" | "prod" | "staging";
+        workDayId: string;
+        state: string;
+        totalTasks: number;
+        completedTasks: number;
+        failedTasks: number;
+        queuedTasks: number;
+        activeTasks: number;
+        dailyTaskCreditBudget: number;
+        usedTaskCredits: number;
+        remainingTaskCredits: number;
+        creditLedgerEntries: number;
+        prioritySnapshotId: string;
+        priorityItemCount: number;
+        priorityItems: import("@treeseed/sdk").PrioritySnapshotItem[];
+        taskItems: {
+            id: string;
+            agentId: string;
+            type: string;
+            state: string;
+            priority: number;
+            idempotencyKey: string;
+            createdAt: string;
+            startedAt: string;
+            completedAt: string;
+            lastErrorCode: string;
+            lastErrorMessage: string;
+            lastEventKind: string;
+            outputCount: number;
+            changedFiles: string[];
+        }[];
+        changedFiles: string[];
+        releases: {
+            id: string;
+            deploymentKind: string;
+            status: string;
+            releaseTag: string;
+            commitSha: string;
+            sourceRef: string;
+            startedAt: string;
+            finishedAt: string;
+            createdAt: string;
+        }[];
+        scaleDecision: import("@treeseed/sdk").ScaleDecision;
+        scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+        generatedAt: string;
+    };
+    scale: import("@treeseed/sdk").WorkerPoolScaleResult;
+    skipped?: undefined;
+    reason?: undefined;
+} | {
     ok: boolean;
     skipped: boolean;
+    reason: string;
     workDayId?: undefined;
     summary?: undefined;
 } | {
     ok: boolean;
-    workDayId: string;
+    workDayId: unknown;
     summary: {
+        contentSnapshot: {
+            relativePath: string;
+            slug: string;
+            reportVersion: string;
+            title: string;
+        };
+        projectId: string;
+        environment: "local" | "prod" | "staging";
+        workDayId: string;
+        state: string;
         totalTasks: number;
         completedTasks: number;
         failedTasks: number;
-        pendingTasks: number;
+        queuedTasks: number;
+        activeTasks: number;
+        dailyTaskCreditBudget: number;
+        usedTaskCredits: number;
+        remainingTaskCredits: number;
+        creditLedgerEntries: number;
+        prioritySnapshotId: string;
+        priorityItemCount: number;
+        priorityItems: import("@treeseed/sdk").PrioritySnapshotItem[];
+        taskItems: {
+            id: string;
+            agentId: string;
+            type: string;
+            state: string;
+            priority: number;
+            idempotencyKey: string;
+            createdAt: string;
+            startedAt: string;
+            completedAt: string;
+            lastErrorCode: string;
+            lastErrorMessage: string;
+            lastEventKind: string;
+            outputCount: number;
+            changedFiles: string[];
+        }[];
+        changedFiles: string[];
+        releases: {
+            id: string;
+            deploymentKind: string;
+            status: string;
+            releaseTag: string;
+            commitSha: string;
+            sourceRef: string;
+            startedAt: string;
+            finishedAt: string;
+            createdAt: string;
+        }[];
+        scaleDecision: import("@treeseed/sdk").ScaleDecision;
+        scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+        generatedAt: string;
     };
     skipped?: undefined;
+    reason?: undefined;
 }>;

package/dist/services/workday-report.js

@@ -1,37 +1,10 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
-import { createGatewayClient, createServiceSdk } from "./common.js";
+import { runManagerAction } from "./manager.js";
 async function runWorkdayReport() {
-  const sdk = createServiceSdk();
-  const gateway = createGatewayClient();
-  const workDays = await sdk.search({ model: "work_day", limit: 1 });
-  const active = workDays.payload[0];
-  if (!active || typeof active.id !== "string") {
-    return { ok: true, skipped: true };
-  }
-  const tasks = await sdk.searchTasks({ workDayId: active.id, limit: 200 });
-  const summary = {
-    totalTasks: tasks.payload.length,
-    completedTasks: tasks.payload.filter((entry) => entry.state === "completed").length,
-    failedTasks: tasks.payload.filter((entry) => entry.state === "failed").length,
-    pendingTasks: tasks.payload.filter((entry) => entry.state !== "completed" && entry.state !== "failed").length
-  };
-  if (gateway) {
-    await gateway.requestJson("/reports", {
-      body: {
-        workDayId: active.id,
-        kind: "workday_summary",
-        body: summary
-      }
-    });
-    await gateway.requestJson(`/workdays/${encodeURIComponent(active.id)}/close`, {
-      body: {
-        state: "completed",
-        summary
-      }
-    });
-  }
-  return { ok: true, workDayId: active.id, summary };
+  return runManagerAction({
+    mode: "report-workday"
+  });
 }
 const currentFile = fileURLToPath(import.meta.url);
 const entryFile = process.argv[1] ?? "";