@treeseed/core 0.4.6 → 0.4.7

package/dist/scripts/run-fixture-astro-command.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, rmSync, symlinkSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { dirname, resolve } from 'node:path';
 import { createRequire } from 'node:module';
@@ -54,176 +54,8 @@ function ensureFixtureWorkspacePackage(packageName, workspaceDir) {
     rmSync(packageDir, { recursive: true, force: true });
     symlinkSync(resolvedPackageRoot, packageDir, 'dir');
 }
-function ensureFixtureAgentContractPackage() {
-    const packageDir = resolve(fixtureRoot, 'node_modules', '@treeseed', 'agent');
-    mkdirSync(resolve(packageDir, 'contracts'), { recursive: true });
-    writeFileSync(resolve(packageDir, 'package.json'), JSON.stringify({
-        name: '@treeseed/agent',
-        type: 'module',
-        exports: {
-            './runtime-types': {
-                types: './runtime-types.d.js',
-                default: './runtime-types.js',
-            },
-            './contracts/messages': {
-                types: './contracts/messages.d.js',
-                default: './contracts/messages.js',
-            },
-            './contracts/run': {
-                types: './contracts/run.d.js',
-                default: './contracts/run.js',
-            },
-        },
-    }, null, 2), 'utf8');
-    writeFileSync(resolve(packageDir, 'runtime-types.js'), 'export {};\n', 'utf8');
-    writeFileSync(resolve(packageDir, 'runtime-types.d.ts'), [
-        "import type { AgentHandlerKind, AgentRunStatus } from '@treeseed/sdk/types/agents';",
-        'export interface AgentTriggerInvocation {',
-        "\tkind: 'startup' | 'schedule' | 'message' | 'manual' | 'follow';",
-        '\tsource: string;',
-        '\tmessage?: { id?: string | number; type?: string; payloadJson?: string | null } | null;',
-        '}',
-        'export interface AgentExecutionResult {',
-        '\tstatus: AgentRunStatus;',
-        '\tsummary: string;',
-        '\tstdout?: string;',
-        '\tstderr?: string;',
-        "\terrorCategory?: import('./contracts/run.js').AgentErrorCategory | null;",
-        '\tmetadata?: Record<string, unknown>;',
-        '}',
-        'export interface AgentContext {',
-        '\trunId: string;',
-        '\trepoRoot: string;',
-        '\tagent: any;',
-        '\tsdk: any;',
-        '\ttrigger: AgentTriggerInvocation;',
-        '\texecution: any;',
-        '\tmutations: any;',
-        '\trepository: any;',
-        '\tverification: any;',
-        '\tnotifications: any;',
-        '\tresearch: any;',
-        '}',
-        'export interface AgentHandler<TInputs = unknown, TResult = unknown> {',
-        '\tkind: AgentHandlerKind;',
-        '\tresolveInputs(context: AgentContext): Promise<TInputs>;',
-        '\texecute(context: AgentContext, inputs: TInputs): Promise<TResult>;',
-        '\temitOutputs(context: AgentContext, result: TResult): Promise<AgentExecutionResult>;',
-        '}',
-        '',
-    ].join('\n'), 'utf8');
-    writeFileSync(resolve(packageDir, 'contracts', 'messages.js'), [
-        'export const AGENT_MESSAGE_TYPES = {};',
-        'export function parseAgentMessagePayload(_type, payloadJson) {',
-        '\treturn JSON.parse(payloadJson);',
-        '}',
-        '',
-    ].join('\n'), 'utf8');
-    writeFileSync(resolve(packageDir, 'contracts', 'messages.d.ts'), [
-        'export interface QuestionPriorityUpdatedMessage {',
-        '\tquestionId: string;',
-        '\treason: string;',
-        '\tplannerRunId: string;',
-        '}',
-        'export interface ObjectivePriorityUpdatedMessage {',
-        '\tobjectiveId: string;',
-        '\treason: string;',
-        '\tplannerRunId: string;',
-        '}',
-        'export interface ArchitectureUpdatedMessage {',
-        '\tobjectiveId: string;',
-        '\tknowledgeId: string;',
-        '\tarchitectRunId: string;',
-        '}',
-        'export interface SubscriberNotifiedMessage {',
-        '\temail: string;',
-        '\titemCount: number;',
-        '\tnotifierRunId: string;',
-        '}',
-        'export interface ResearchStartedMessage {',
-        '\tquestionId: string;',
-        '\tresearcherRunId: string;',
-        '}',
-        'export interface ResearchCompletedMessage {',
-        '\tquestionId: string;',
-        '\tknowledgeId: string | null;',
-        '\tresearcherRunId: string;',
-        '}',
-        'export interface TaskCompleteMessage {',
-        '\tbranchName: string | null;',
-        '\tchangedTargets: string[];',
-        '\tengineerRunId: string;',
-        '}',
-        'export interface TaskWaitingMessage {',
-        '\tblockingReason: string;',
-        '\tengineerRunId: string;',
-        '}',
-        'export interface TaskFailedMessage {',
-        '\tfailureSummary: string;',
-        '\tengineerRunId: string;',
-        '}',
-        'export interface TaskVerifiedMessage {',
-        '\tbranchName: string | null;',
-        '\treviewerRunId: string;',
-        '}',
-        'export interface ReviewFailedMessage {',
-        '\tfailureSummary: string;',
-        '\treviewerRunId: string;',
-        '}',
-        'export interface ReviewWaitingMessage {',
-        '\tblockingReason: string;',
-        '\treviewerRunId: string;',
-        '}',
-        'export interface ReleaseStartedMessage {',
-        '\ttaskRunId: string | null;',
-        '\treleaserRunId: string;',
-        '}',
-        'export interface ReleaseCompletedMessage {',
-        '\treleaseSummary: string;',
-        '\treleaserRunId: string;',
-        '}',
-        'export interface ReleaseFailedMessage {',
-        '\tfailureSummary: string;',
-        '\treleaserRunId: string;',
-        '}',
-        'export interface AgentMessageContracts {',
-        '\tquestion_priority_updated: QuestionPriorityUpdatedMessage;',
-        '\tobjective_priority_updated: ObjectivePriorityUpdatedMessage;',
-        '\tarchitecture_updated: ArchitectureUpdatedMessage;',
-        '\tsubscriber_notified: SubscriberNotifiedMessage;',
-        '\tresearch_started: ResearchStartedMessage;',
-        '\tresearch_completed: ResearchCompletedMessage;',
-        '\ttask_complete: TaskCompleteMessage;',
-        '\ttask_waiting: TaskWaitingMessage;',
-        '\ttask_failed: TaskFailedMessage;',
-        '\ttask_verified: TaskVerifiedMessage;',
-        '\treview_failed: ReviewFailedMessage;',
-        '\treview_waiting: ReviewWaitingMessage;',
-        '\trelease_started: ReleaseStartedMessage;',
-        '\trelease_completed: ReleaseCompletedMessage;',
-        '\trelease_failed: ReleaseFailedMessage;',
-        '}',
-        'export type AgentMessageType = keyof AgentMessageContracts;',
-        'export type AgentMessagePayload<TType extends AgentMessageType> = AgentMessageContracts[TType];',
-        'export declare const AGENT_MESSAGE_TYPES: readonly AgentMessageType[];',
-        'export declare function parseAgentMessagePayload<TType extends AgentMessageType>(_type: TType, payloadJson: string): AgentMessagePayload<TType>;',
-        '',
-    ].join('\n'), 'utf8');
-    writeFileSync(resolve(packageDir, 'contracts', 'run.js'), 'export {};\n', 'utf8');
-    writeFileSync(resolve(packageDir, 'contracts', 'run.d.ts'), [
-        "export type AgentErrorCategory = 'execution_error' | 'mutation_error' | 'verification_error' | 'notification_error' | 'research_error' | 'sdk_error' | 'unknown';",
-        '',
-    ].join('\n'), 'utf8');
-}
 ensureFixtureWorkspacePackage('@treeseed/sdk', resolve(packageRoot, '..', 'sdk'));
-const workspaceAgentRoot = resolve(packageRoot, '..', 'agent');
-if (existsSync(workspaceAgentRoot) || resolveInstalledPackageRoot('@treeseed/agent')) {
-    ensureFixtureWorkspacePackage('@treeseed/agent', workspaceAgentRoot);
-}
-else {
-    rmSync(resolve(fixtureRoot, 'node_modules', '@treeseed', 'agent'), { recursive: true, force: true });
-    ensureFixtureAgentContractPackage();
-}
+ensureFixtureWorkspacePackage('@treeseed/core', packageRoot);
 const result = spawnSync('npx', ['astro', command, '--root', fixtureRoot, ...rest], {
     cwd: packageRoot,
     stdio: 'inherit',

package/dist/scripts/test-smoke.js

@@ -108,7 +108,21 @@ try {
     installPackagedPackage(extractRoot, installRoot, coreTarball, 'core');
     mirrorDependencies(installRoot);
     writeFileSync(resolve(installRoot, 'package.json'), `${JSON.stringify({ name: 'treeseed-core-smoke', private: true, type: 'module' }, null, 2)}\n`, 'utf8');
-    run(process.execPath, ['--input-type=module', '-e', 'await import("@treeseed/core");'], installRoot);
+    run(process.execPath, [
+        '--input-type=module',
+        '-e',
+        [
+            'await import("@treeseed/core");',
+            'await import("@treeseed/core/agent/cli");',
+            'await import("@treeseed/core/runtime-types");',
+            'await import("@treeseed/core/contracts/messages");',
+            'await import("@treeseed/core/contracts/run");',
+            'await import("@treeseed/core/services/manager");',
+            'await import("@treeseed/core/services/worker");',
+            'await import("@treeseed/core/services/workday-start");',
+            'await import("@treeseed/core/services/workday-report");',
+        ].join(' '),
+    ], installRoot);
     console.log('Core packed-install smoke passed.');
 }
 finally {

package/dist/scripts/workspace-bootstrap.js

@@ -8,7 +8,6 @@ const require = createRequire(import.meta.url);
 const requiredPackages = [
     { name: '@treeseed/sdk', dir: 'packages/sdk', build: true },
     { name: '@treeseed/core', dir: 'packages/core', build: true },
-    { name: '@treeseed/agent', dir: 'packages/agent', build: true },
     { name: '@treeseed/cli', dir: 'packages/cli', build: true, binName: 'treeseed' },
 ];
 function packageState(root, entry) {

package/dist/services/common.d.ts

@@ -0,0 +1,20 @@
+import { AgentSdk } from '@treeseed/sdk/sdk';
+import { TreeseedGatewayClient, CloudflareQueuePullClient } from '@treeseed/sdk/remote';
+export declare function resolveServiceRepoRoot(): string;
+export declare function createServiceSdk(): AgentSdk;
+export declare function createGatewayClient(): TreeseedGatewayClient;
+export declare function createQueueClient(): CloudflareQueuePullClient;
+export declare function resolveManagerConfig(): {
+    host: string;
+    port: number;
+    projectId: string;
+    defaultCapacityBudget: number;
+};
+export declare function resolveWorkerConfig(): {
+    workerId: string;
+    batchSize: number;
+    visibilityTimeoutMs: number;
+    pollIntervalMs: number;
+    leaseSeconds: number;
+    managerBaseUrl: string;
+};

package/dist/services/common.js

@@ -0,0 +1,66 @@
+import { AgentSdk } from "@treeseed/sdk/sdk";
+import { TreeseedGatewayClient, CloudflareQueuePullClient } from "@treeseed/sdk/remote";
+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 resolveServiceRepoRoot() {
+  return process.env.TREESEED_AGENT_REPO_ROOT?.trim() || process.cwd();
+}
+function createServiceSdk() {
+  return AgentSdk.createLocal({
+    repoRoot: resolveServiceRepoRoot(),
+    databaseName: process.env.TREESEED_AGENT_D1_DATABASE ?? "karyon-docs-site-data",
+    persistTo: process.env.TREESEED_AGENT_D1_PERSIST_TO ?? void 0
+  });
+}
+function createGatewayClient() {
+  const baseUrl = process.env.TREESEED_GATEWAY_BASE_URL?.trim();
+  const bearerToken = process.env.TREESEED_GATEWAY_BEARER_TOKEN?.trim();
+  if (!baseUrl || !bearerToken) {
+    return null;
+  }
+  return new TreeseedGatewayClient({ baseUrl, bearerToken });
+}
+function createQueueClient() {
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID?.trim();
+  const queueId = process.env.TREESEED_QUEUE_ID?.trim();
+  const token = process.env.TREESEED_QUEUE_PULL_TOKEN?.trim();
+  if (!accountId || !queueId || !token) {
+    return null;
+  }
+  return new CloudflareQueuePullClient({
+    accountId,
+    queueId,
+    token,
+    apiBaseUrl: process.env.TREESEED_QUEUE_API_BASE_URL?.trim() || void 0
+  });
+}
+function resolveManagerConfig() {
+  return {
+    host: process.env.HOST?.trim() || "0.0.0.0",
+    port: integerFromEnv("PORT", 3100),
+    projectId: process.env.TREESEED_PROJECT_ID?.trim() || "treeseed-market",
+    defaultCapacityBudget: integerFromEnv("TREESEED_WORKDAY_CAPACITY_BUDGET", 100)
+  };
+}
+function resolveWorkerConfig() {
+  return {
+    workerId: process.env.TREESEED_WORKER_ID?.trim() || `worker-${process.pid}`,
+    batchSize: integerFromEnv("TREESEED_QUEUE_BATCH_SIZE", 1),
+    visibilityTimeoutMs: integerFromEnv("TREESEED_QUEUE_VISIBILITY_TIMEOUT_MS", 12e4),
+    pollIntervalMs: integerFromEnv("TREESEED_WORKER_POLL_INTERVAL_MS", 5e3),
+    leaseSeconds: integerFromEnv("TREESEED_TASK_LEASE_SECONDS", 120),
+    managerBaseUrl: process.env.TREESEED_MANAGER_BASE_URL?.trim() || `http://${process.env.TREESEED_MANAGER_HOST?.trim() || "manager.railway.internal"}:${integerFromEnv("TREESEED_MANAGER_PORT", 3100)}`
+  };
+}
+export {
+  createGatewayClient,
+  createQueueClient,
+  createServiceSdk,
+  resolveManagerConfig,
+  resolveServiceRepoRoot,
+  resolveWorkerConfig
+};

package/dist/services/index.d.ts

@@ -0,0 +1,4 @@
+export { createManagerApp } from './manager.ts';
+export { runWorkerCycle, startWorkerLoop } from './worker.ts';
+export { runWorkdayStart } from './workday-start.ts';
+export { runWorkdayReport } from './workday-report.ts';

package/dist/services/index.js

@@ -0,0 +1,11 @@
+import { createManagerApp } from "./manager.js";
+import { runWorkerCycle, startWorkerLoop } from "./worker.js";
+import { runWorkdayStart } from "./workday-start.js";
+import { runWorkdayReport } from "./workday-report.js";
+export {
+  createManagerApp,
+  runWorkdayReport,
+  runWorkdayStart,
+  runWorkerCycle,
+  startWorkerLoop
+};

package/dist/services/manager.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { Hono } from 'hono';
+import { AgentSdk } from '@treeseed/sdk/sdk';
+export declare function createManagerApp(sdk?: AgentSdk): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/services/manager.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+import { Hono } from "hono";
+import { AgentSdk } from "@treeseed/sdk/sdk";
+import { createServiceSdk, resolveManagerConfig } from "./common.js";
+async function honoNodeHandler(app, request, response) {
+  const origin = request.headers.host ? `http://${request.headers.host}` : "http://127.0.0.1";
+  const url = new URL(request.url ?? "/", origin);
+  const webRequest = new Request(url, {
+    method: request.method,
+    headers: request.headers,
+    body: request.method !== "GET" && request.method !== "HEAD" ? request : void 0,
+    duplex: "half"
+  });
+  const webResponse = await app.fetch(webRequest);
+  response.statusCode = webResponse.status;
+  webResponse.headers.forEach((value, key) => response.setHeader(key, value));
+  if (!webResponse.body) {
+    response.end();
+    return;
+  }
+  Readable.fromWeb(webResponse.body).pipe(response);
+}
+async function seedRootTasks(sdk, workDayId) {
+  const specs = await sdk.listAgentSpecs({ enabled: true });
+  const created = [];
+  for (const spec of specs) {
+    const hasStartTrigger = spec.triggers.some((trigger) => trigger.type === "startup" || trigger.type === "schedule");
+    if (!hasStartTrigger) continue;
+    created.push(await sdk.createTask({
+      workDayId,
+      agentId: spec.slug,
+      type: "agent_root",
+      priority: 100,
+      idempotencyKey: `${workDayId}:${spec.slug}:root`,
+      payload: {
+        agentSlug: spec.slug,
+        handler: spec.handler,
+        triggerKinds: spec.triggers.map((entry) => entry.type)
+      },
+      graphVersion: null,
+      actor: "manager"
+    }));
+  }
+  return created;
+}
+function createManagerApp(sdk = createServiceSdk()) {
+  const config = resolveManagerConfig();
+  const app = new Hono();
+  app.get("/internal/healthz", (c) => c.json({ ok: true, service: "manager" }));
+  app.post("/internal/workdays/start", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const graphRefresh = await sdk.refreshGraph();
+    const workDay = await sdk.startWorkDay({
+      id: typeof body.id === "string" ? body.id : void 0,
+      projectId: config.projectId,
+      capacityBudget: Number(body.capacityBudget ?? config.defaultCapacityBudget),
+      graphVersion: graphRefresh.snapshotRoot,
+      summary: { graphRefresh },
+      actor: "manager"
+    });
+    const tasks = workDay.payload ? await seedRootTasks(sdk, String(workDay.payload.id)) : [];
+    return c.json({
+      ok: true,
+      workDay: workDay.payload,
+      seededTasks: tasks.map((entry) => entry.payload).filter(Boolean)
+    });
+  });
+  app.post("/internal/workdays/:id/close", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const result = await sdk.closeWorkDay({
+      id: c.req.param("id"),
+      state: body.state,
+      summary: body.summary ?? null,
+      actor: "manager"
+    });
+    return c.json({ ok: true, payload: result.payload });
+  });
+  app.post("/internal/context/resolve-task", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const taskId = String(body.taskId ?? "");
+    const context = await sdk.getManagerContext(taskId);
+    const task = context.payload.task;
+    const agent = task ? (await sdk.get({ model: "agent", slug: String(task.agentId) })).payload : null;
+    return c.json({
+      ok: true,
+      payload: {
+        ...context.payload,
+        agent
+      }
+    });
+  });
+  app.post("/internal/graph/search", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const query = String(body.query ?? "");
+    const scope = String(body.scope ?? "sections");
+    const payload = scope === "files" ? await sdk.searchFiles(query, body.options) : scope === "entities" ? await sdk.searchEntities(query, body.options) : await sdk.searchSections(query, body.options);
+    return c.json({ ok: true, payload });
+  });
+  app.post("/internal/graph/subgraph", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const payload = await sdk.getSubgraph(
+      Array.isArray(body.seedIds) ? body.seedIds.map(String) : [],
+      body.options
+    );
+    return c.json({ ok: true, payload });
+  });
+  app.post("/internal/graph/query", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const payload = await sdk.queryGraph(body);
+    if (typeof body.workDayId === "string" && body.workDayId) {
+      await sdk.create({
+        model: "graph_run",
+        data: {
+          workDayId: body.workDayId,
+          corpusHash: String(body.corpusHash ?? "query-graph"),
+          graphVersion: String(body.graphVersion ?? ""),
+          queryJson: JSON.stringify(body ?? {}),
+          seedIdsJson: JSON.stringify(payload.seedIds),
+          selectedNodeIdsJson: JSON.stringify(payload.nodes.map((entry) => entry.node.id)),
+          statsJson: JSON.stringify({ nodeCount: payload.nodes.length, edgeCount: payload.edges.length })
+        },
+        actor: "manager"
+      });
+    }
+    return c.json({ ok: true, payload });
+  });
+  app.post("/internal/graph/context-pack", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const payload = await sdk.buildContextPack(body);
+    if (typeof body.workDayId === "string" && body.workDayId) {
+      await sdk.create({
+        model: "graph_run",
+        data: {
+          workDayId: body.workDayId,
+          corpusHash: String(body.corpusHash ?? "context-pack"),
+          graphVersion: String(body.graphVersion ?? ""),
+          queryJson: JSON.stringify(body ?? {}),
+          seedIdsJson: JSON.stringify(payload.seedIds),
+          selectedNodeIdsJson: JSON.stringify(payload.includedNodeIds),
+          statsJson: JSON.stringify({ nodeCount: payload.nodes.length, edgeCount: payload.edges.length, totalTokenEstimate: payload.totalTokenEstimate })
+        },
+        actor: "manager"
+      });
+    }
+    return c.json({ ok: true, payload });
+  });
+  app.post("/internal/graph/parse-dsl", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const payload = await sdk.parseGraphDsl(String(body.source ?? body.query ?? ""));
+    return c.json({ ok: true, payload });
+  });
+  app.get("/internal/graph/node/:id", async (c) => {
+    const payload = await sdk.getGraphNode(c.req.param("id"));
+    return payload ? c.json({ ok: true, payload }) : c.json({ ok: false, error: "Unknown graph node." }, 404);
+  });
+  app.post("/internal/tasks/:id/followups", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const current = await sdk.get({ model: "task", id: c.req.param("id") });
+    if (!current.payload) {
+      return c.json({ ok: false, error: "Unknown task." }, 404);
+    }
+    const followups = Array.isArray(body.followups) ? body.followups : [];
+    const created = [];
+    for (const followup of followups) {
+      created.push(await sdk.createTask({
+        workDayId: String(current.payload.workDayId ?? ""),
+        agentId: String(followup.agentId ?? current.payload.agentId ?? ""),
+        type: String(followup.type ?? "followup"),
+        priority: Number(followup.priority ?? 0),
+        idempotencyKey: String(followup.idempotencyKey ?? `${c.req.param("id")}:${created.length}`),
+        payload: followup.payload ?? {},
+        graphVersion: typeof followup.graphVersion === "string" ? followup.graphVersion : null,
+        parentTaskId: c.req.param("id"),
+        actor: "manager"
+      }));
+    }
+    return c.json({ ok: true, payload: created.map((entry) => entry.payload) });
+  });
+  return app;
+}
+const currentFile = fileURLToPath(import.meta.url);
+const entryFile = process.argv[1] ?? "";
+if (entryFile === currentFile) {
+  const config = resolveManagerConfig();
+  const app = createManagerApp();
+  const server = createServer((req, res) => {
+    void honoNodeHandler(app, req, res);
+  });
+  server.listen(config.port, config.host, () => {
+    process.stdout.write(`Treeseed manager listening on http://${config.host}:${config.port}
+`);
+  });
+}
+export {
+  createManagerApp
+};

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

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+export declare function runWorkdayReport(): Promise<{
+    ok: boolean;
+    skipped: boolean;
+    workDayId?: undefined;
+    summary?: undefined;
+} | {
+    ok: boolean;
+    workDayId: string;
+    summary: {
+        totalTasks: number;
+        completedTasks: number;
+        failedTasks: number;
+        pendingTasks: number;
+    };
+    skipped?: undefined;
+}>;

package/dist/services/workday-report.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { createGatewayClient, createServiceSdk } from "./common.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 };
+}
+const currentFile = fileURLToPath(import.meta.url);
+const entryFile = process.argv[1] ?? "";
+if (entryFile === currentFile) {
+  process.stdout.write(`${JSON.stringify(await runWorkdayReport(), null, 2)}
+`);
+}
+export {
+  runWorkdayReport
+};

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runWorkdayStart(): Promise<any>;

package/dist/services/workday-start.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { resolveWorkerConfig } from "./common.js";
+async function runWorkdayStart() {
+  const managerBaseUrl = resolveWorkerConfig().managerBaseUrl;
+  const response = await fetch(`${managerBaseUrl}/internal/workdays/start`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({})
+  });
+  if (!response.ok) {
+    throw new Error(`Workday start failed with ${response.status}.`);
+  }
+  return response.json();
+}
+const currentFile = fileURLToPath(import.meta.url);
+const entryFile = process.argv[1] ?? "";
+if (entryFile === currentFile) {
+  process.stdout.write(`${JSON.stringify(await runWorkdayStart(), null, 2)}
+`);
+}
+export {
+  runWorkdayStart
+};

package/dist/services/worker.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+export declare function runWorkerCycle(): Promise<{
+    ok: boolean;
+    processed: number;
+}>;
+export declare function startWorkerLoop(): Promise<void>;