@treeseed/core 0.4.1 → 0.4.4

package/dist/api/index.d.ts

@@ -0,0 +1,9 @@
+export { createTreeseedApiApp } from './app.ts';
+export { createTreeseedGatewayApp } from './gateway.ts';
+export { resolveApiConfig } from './config.ts';
+export { createRailwayTreeseedApiServer } from './railway.ts';
+export { resolveApiRuntimeProviders } from './providers.ts';
+export { loadTemplateCatalog } from './templates.ts';
+export { MemoryDeviceCodeAuthProvider } from './auth/memory-provider.ts';
+export { D1AuthProvider } from './auth/d1-provider.ts';
+export type * from './types.ts';

package/dist/api/index.js

@@ -0,0 +1,18 @@
+import { createTreeseedApiApp } from "./app.js";
+import { createTreeseedGatewayApp } from "./gateway.js";
+import { resolveApiConfig } from "./config.js";
+import { createRailwayTreeseedApiServer } from "./railway.js";
+import { resolveApiRuntimeProviders } from "./providers.js";
+import { loadTemplateCatalog } from "./templates.js";
+import { MemoryDeviceCodeAuthProvider } from "./auth/memory-provider.js";
+import { D1AuthProvider } from "./auth/d1-provider.js";
+export {
+  D1AuthProvider,
+  MemoryDeviceCodeAuthProvider,
+  createRailwayTreeseedApiServer,
+  createTreeseedApiApp,
+  createTreeseedGatewayApp,
+  loadTemplateCatalog,
+  resolveApiConfig,
+  resolveApiRuntimeProviders
+};

package/dist/api/operations-routes.d.ts

@@ -0,0 +1,6 @@
+import type { Hono } from 'hono';
+import { executeHttpWorkflowOperation } from './operations.ts';
+export declare function registerOperationRoutes(app: Hono<any>, options: {
+    scope: string;
+    executeOperation?: typeof executeHttpWorkflowOperation;
+}): void;

package/dist/api/operations-routes.js

@@ -0,0 +1,34 @@
+import { findTreeseedOperation } from "@treeseed/sdk";
+import { executeHttpWorkflowOperation, isHttpWorkflowOperationAllowed } from "./operations.js";
+import { jsonError, requireScope } from "./http.js";
+function registerOperationRoutes(app, options) {
+  const executeOperation = options.executeOperation ?? executeHttpWorkflowOperation;
+  app.post("/operations/:operation", async (c) => {
+    const unauthorized = requireScope(c, options.scope);
+    if (unauthorized) return unauthorized;
+    const requestedOperation = c.req.param("operation");
+    const resolvedOperation = findTreeseedOperation(requestedOperation);
+    if (!resolvedOperation) {
+      return jsonError(c, 400, `Unknown Treeseed operation "${requestedOperation}".`, {
+        operation: requestedOperation
+      });
+    }
+    if (!isHttpWorkflowOperationAllowed(resolvedOperation.name)) {
+      return jsonError(c, 400, `Workflow operation "${resolvedOperation.name}" is not supported over HTTP.`, {
+        operation: resolvedOperation.name
+      });
+    }
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      const result = await executeOperation(resolvedOperation.name, body);
+      return c.json(result, { status: result.ok ? 200 : 400 });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = /Unknown Treeseed operation|not supported over HTTP|confirmation required/i.test(message) ? 400 : 500;
+      return jsonError(c, status, message, { operation: resolvedOperation.name });
+    }
+  });
+}
+export {
+  registerOperationRoutes
+};

package/dist/api/operations.d.ts

@@ -0,0 +1,3 @@
+import type { ApiWorkflowOperationResponse, WorkflowHttpOperationRequest } from './types.ts';
+export declare function isHttpWorkflowOperationAllowed(operation: string): boolean;
+export declare function executeHttpWorkflowOperation(operation: string, request: WorkflowHttpOperationRequest): Promise<ApiWorkflowOperationResponse>;

package/dist/api/operations.js

@@ -0,0 +1,26 @@
+import { TreeseedOperationsSdk } from "@treeseed/sdk";
+const HTTP_BLOCKED_WORKFLOW_OPERATIONS = /* @__PURE__ */ new Set(["dev", "dev:watch"]);
+function isHttpWorkflowOperationAllowed(operation) {
+  return !HTTP_BLOCKED_WORKFLOW_OPERATIONS.has(operation);
+}
+async function executeHttpWorkflowOperation(operation, request) {
+  if (!isHttpWorkflowOperationAllowed(operation)) {
+    throw new Error(`Workflow operation "${operation}" is not supported over HTTP.`);
+  }
+  const operations = new TreeseedOperationsSdk();
+  return operations.execute({
+    operationName: operation,
+    input: request.input ?? {}
+  }, {
+    cwd: request.cwd ?? process.cwd(),
+    env: {
+      ...process.env,
+      ...request.env ?? {}
+    },
+    transport: "api"
+  });
+}
+export {
+  executeHttpWorkflowOperation,
+  isHttpWorkflowOperationAllowed
+};

package/dist/api/providers.d.ts

@@ -0,0 +1,2 @@
+import type { ApiConfig, ApiRuntimeProviders, ResolvedApiRuntimeProviders } from './types.ts';
+export declare function resolveApiRuntimeProviders(config: ApiConfig, overrides?: ApiRuntimeProviders): ResolvedApiRuntimeProviders;

package/dist/api/providers.js

@@ -0,0 +1,61 @@
+import { MemoryDeviceCodeAuthProvider } from "./auth/memory-provider.js";
+import { D1AuthProvider } from "./auth/d1-provider.js";
+function addProviders(target, incoming, label) {
+  for (const [id, value] of Object.entries(incoming ?? {})) {
+    if (target.has(id)) {
+      throw new Error(`Treeseed API runtime found duplicate ${label} provider "${id}".`);
+    }
+    target.set(id, value);
+  }
+}
+function resolveSelectedProvider(registry, selectedId, label) {
+  const selected = registry.get(selectedId);
+  if (!selected) {
+    throw new Error(`Treeseed API runtime could not resolve ${label} provider "${selectedId}".`);
+  }
+  return selected;
+}
+function resolveApiRuntimeProviders(config, overrides = {}) {
+  const authRegistry = /* @__PURE__ */ new Map();
+  const agentExecution = /* @__PURE__ */ new Map();
+  const agentQueue = /* @__PURE__ */ new Map();
+  const agentNotification = /* @__PURE__ */ new Map();
+  const agentRepository = /* @__PURE__ */ new Map();
+  const agentVerification = /* @__PURE__ */ new Map();
+  addProviders(authRegistry, {
+    memory: ({ config: runtimeConfig }) => new MemoryDeviceCodeAuthProvider(runtimeConfig),
+    d1: ({ config: runtimeConfig }) => new D1AuthProvider(runtimeConfig)
+  }, "auth");
+  addProviders(authRegistry, overrides.auth, "auth");
+  addProviders(agentExecution, { stub: { id: "stub" } }, "agent execution");
+  addProviders(agentQueue, { memory: { id: "memory" } }, "agent queue");
+  addProviders(agentNotification, { stub: { id: "stub" } }, "agent notification");
+  addProviders(agentRepository, { stub: { id: "stub" } }, "agent repository");
+  addProviders(agentVerification, { stub: { id: "stub" } }, "agent verification");
+  addProviders(agentExecution, overrides.agentExecution, "agent execution");
+  addProviders(agentQueue, overrides.agentQueue, "agent queue");
+  addProviders(agentNotification, overrides.agentNotification, "agent notification");
+  addProviders(agentRepository, overrides.agentRepository, "agent repository");
+  addProviders(agentVerification, overrides.agentVerification, "agent verification");
+  const authFactory = resolveSelectedProvider(authRegistry, config.providers.auth, "auth");
+  resolveSelectedProvider(agentExecution, config.providers.agents.execution, "agent execution");
+  resolveSelectedProvider(agentQueue, config.providers.agents.queue, "agent queue");
+  resolveSelectedProvider(agentNotification, config.providers.agents.notification, "agent notification");
+  resolveSelectedProvider(agentRepository, config.providers.agents.repository, "agent repository");
+  resolveSelectedProvider(agentVerification, config.providers.agents.verification, "agent verification");
+  return {
+    auth: authFactory({ config }),
+    registries: {
+      auth: authRegistry,
+      agentExecution,
+      agentQueue,
+      agentNotification,
+      agentRepository,
+      agentVerification
+    },
+    selections: config.providers
+  };
+}
+export {
+  resolveApiRuntimeProviders
+};

package/dist/api/railway.d.ts

@@ -0,0 +1,45 @@
+import { type Server } from 'node:http';
+import type { Hono } from 'hono';
+import type { ApiServerOptions } from './types.ts';
+export declare function createRailwayTreeseedApiServer(options?: ApiServerOptions): Promise<{
+    app: Hono<{
+        Variables: import("./types.ts").AppVariables;
+    }, import("hono/types").BlankSchema, "/">;
+    config: {
+        providers: {
+            agents: {
+                execution: string;
+                queue: string;
+                notification: string;
+                repository: string;
+                verification: string;
+            };
+            auth: string;
+        };
+        name: string;
+        host: string;
+        port: number;
+        baseUrl: string;
+        issuer: string;
+        repoRoot: string;
+        authSecret: string;
+        cloudflareAccountId?: string;
+        cloudflareApiToken?: string;
+        d1DatabaseId?: string;
+        d1DatabaseName?: string;
+        d1LocalPersistTo?: string;
+        webServiceId: string;
+        webServiceSecret: string;
+        webAssertionSecret: string;
+        webExchangeTtlSeconds: number;
+        bootstrapAdminAllowlist: string[];
+        accessTokenTtlSeconds: number;
+        refreshTokenTtlSeconds: number;
+        deviceCodeTtlSeconds: number;
+        deviceCodePollIntervalSeconds: number;
+        templateCatalogPath?: string;
+    };
+    server: Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
+    url: string;
+    close(): Promise<void>;
+}>;

package/dist/api/railway.js

@@ -0,0 +1,69 @@
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+import { createTreeseedApiApp } from "./app.js";
+import { resolveApiConfig } from "./config.js";
+function hasRequestBody(method) {
+  return method !== "GET" && method !== "HEAD";
+}
+async function honoNodeHandler(app, request, response) {
+  const req = request;
+  const res = response;
+  const origin = req.headers.host ? `http://${req.headers.host}` : "http://127.0.0.1";
+  const url = new URL(req.url ?? "/", origin);
+  const webRequest = new Request(url, {
+    method: req.method,
+    headers: req.headers,
+    body: hasRequestBody(req.method) ? req : void 0,
+    duplex: "half"
+  });
+  const webResponse = await app.fetch(webRequest);
+  res.statusCode = webResponse.status;
+  webResponse.headers.forEach((value, key) => {
+    res.setHeader(key, value);
+  });
+  if (!webResponse.body) {
+    res.end();
+    return;
+  }
+  Readable.fromWeb(webResponse.body).pipe(res);
+}
+async function createRailwayTreeseedApiServer(options = {}) {
+  const config = {
+    ...resolveApiConfig(),
+    ...options.config ?? {},
+    providers: {
+      ...resolveApiConfig().providers,
+      ...options.config?.providers ?? {},
+      agents: {
+        ...resolveApiConfig().providers.agents,
+        ...options.config?.providers?.agents ?? {}
+      }
+    }
+  };
+  const app = createTreeseedApiApp({
+    ...options,
+    config
+  });
+  const server = createServer((req, res) => {
+    void honoNodeHandler(app, req, res);
+  });
+  await new Promise((resolvePromise) => {
+    server.listen(config.port, config.host, () => resolvePromise());
+  });
+  const address = server.address();
+  const resolvedUrl = address ? `${config.baseUrl.startsWith("http") ? config.baseUrl : `http://${address.address}:${address.port}`}` : config.baseUrl;
+  return {
+    app,
+    config,
+    server,
+    url: resolvedUrl,
+    async close() {
+      await new Promise((resolvePromise, rejectPromise) => {
+        server.close((error) => error ? rejectPromise(error) : resolvePromise());
+      });
+    }
+  };
+}
+export {
+  createRailwayTreeseedApiServer
+};

package/dist/api/sdk-dispatch.d.ts

@@ -0,0 +1,14 @@
+import type { AgentSdk, RemoteSdkOperationRequest } from '@treeseed/sdk';
+import type { ApiConfig } from './types.ts';
+type JsonRecord = Record<string, unknown>;
+type SdkOperationHandler = (sdk: AgentSdk, input: JsonRecord) => Promise<unknown> | unknown;
+interface SdkOperationSpec {
+    name: string;
+    aliases?: string[];
+    handler: SdkOperationHandler;
+}
+export declare function listSdkOperationNames(): string[];
+export declare function findSdkOperation(name: string): SdkOperationSpec;
+export declare function resolveSdkInstance(sharedSdk: AgentSdk | undefined, config: ApiConfig, request: RemoteSdkOperationRequest): AgentSdk;
+export declare function executeSdkOperation(sdk: AgentSdk, operationName: string, input: JsonRecord): Promise<unknown>;
+export {};

package/dist/api/sdk-dispatch.js

@@ -0,0 +1,145 @@
+import { AgentSdk as AgentSdkClass } from "@treeseed/sdk";
+function passthrough(methodName) {
+  return (sdk, input) => sdk[methodName](input);
+}
+const SDK_OPERATION_SPECS = [
+  { name: "get", handler: passthrough("get") },
+  { name: "read", handler: passthrough("read") },
+  { name: "search", handler: passthrough("search") },
+  { name: "follow", handler: passthrough("follow") },
+  { name: "pick", handler: passthrough("pick") },
+  { name: "create", handler: passthrough("create") },
+  { name: "update", handler: passthrough("update") },
+  { name: "claimMessage", aliases: ["claim-message"], handler: passthrough("claimMessage") },
+  { name: "ackMessage", aliases: ["ack-message"], handler: passthrough("ackMessage") },
+  { name: "createMessage", aliases: ["create-message"], handler: passthrough("createMessage") },
+  { name: "recordRun", aliases: ["record-run"], handler: passthrough("recordRun") },
+  { name: "getCursor", aliases: ["get-cursor"], handler: passthrough("getCursor") },
+  { name: "upsertCursor", aliases: ["upsert-cursor"], handler: passthrough("upsertCursor") },
+  { name: "releaseLease", aliases: ["release-lease"], handler: passthrough("releaseLease") },
+  {
+    name: "releaseAllLeases",
+    aliases: ["release-all-leases"],
+    handler: (sdk) => sdk.releaseAllLeases()
+  },
+  { name: "startWorkDay", aliases: ["start-work-day"], handler: passthrough("startWorkDay") },
+  { name: "closeWorkDay", aliases: ["close-work-day"], handler: passthrough("closeWorkDay") },
+  { name: "createTask", aliases: ["create-task"], handler: passthrough("createTask") },
+  { name: "claimTask", aliases: ["claim-task"], handler: passthrough("claimTask") },
+  {
+    name: "recordTaskProgress",
+    aliases: ["record-task-progress"],
+    handler: passthrough("recordTaskProgress")
+  },
+  { name: "completeTask", aliases: ["complete-task"], handler: passthrough("completeTask") },
+  { name: "failTask", aliases: ["fail-task"], handler: passthrough("failTask") },
+  { name: "appendTaskEvent", aliases: ["append-task-event"], handler: passthrough("appendTaskEvent") },
+  { name: "searchTasks", aliases: ["search-tasks"], handler: passthrough("searchTasks") },
+  {
+    name: "getManagerContext",
+    aliases: ["get-manager-context"],
+    handler: (sdk, input) => sdk.getManagerContext(String(input.taskId ?? input.id ?? ""))
+  },
+  { name: "createReport", aliases: ["create-report"], handler: passthrough("createReport") },
+  {
+    name: "listAgentSpecs",
+    aliases: ["list-agent-specs"],
+    handler: (sdk, input) => sdk.listAgentSpecs(input)
+  },
+  { name: "refreshGraph", aliases: ["refresh-graph"], handler: passthrough("refreshGraph") },
+  {
+    name: "searchFiles",
+    aliases: ["search-files"],
+    handler: (sdk, input) => sdk.searchFiles(String(input.query ?? ""), input.options)
+  },
+  {
+    name: "searchSections",
+    aliases: ["search-sections"],
+    handler: (sdk, input) => sdk.searchSections(String(input.query ?? ""), input.options)
+  },
+  {
+    name: "searchEntities",
+    aliases: ["search-entities"],
+    handler: (sdk, input) => sdk.searchEntities(String(input.query ?? ""), input.options)
+  },
+  {
+    name: "getGraphNode",
+    aliases: ["get-graph-node"],
+    handler: (sdk, input) => sdk.getGraphNode(String(input.id ?? ""))
+  },
+  {
+    name: "getNeighbors",
+    aliases: ["get-neighbors"],
+    handler: (sdk, input) => sdk.getNeighbors(String(input.id ?? ""), input.options)
+  },
+  {
+    name: "followReferences",
+    aliases: ["follow-references"],
+    handler: (sdk, input) => sdk.followReferences(String(input.id ?? ""), input.options)
+  },
+  {
+    name: "getBacklinks",
+    aliases: ["get-backlinks"],
+    handler: (sdk, input) => sdk.getBacklinks(String(input.id ?? ""), input.options)
+  },
+  {
+    name: "getRelated",
+    aliases: ["get-related"],
+    handler: (sdk, input) => sdk.getRelated(String(input.id ?? ""), input.options)
+  },
+  {
+    name: "getSubgraph",
+    aliases: ["get-subgraph"],
+    handler: (sdk, input) => sdk.getSubgraph(Array.isArray(input.seedIds) ? input.seedIds.map(String) : [], input.options)
+  },
+  { name: "resolveSeeds", aliases: ["resolve-seeds"], handler: passthrough("resolveSeeds") },
+  { name: "queryGraph", aliases: ["query-graph"], handler: passthrough("queryGraph") },
+  { name: "buildContextPack", aliases: ["build-context-pack"], handler: passthrough("buildContextPack") },
+  {
+    name: "parseGraphDsl",
+    aliases: ["parse-graph-dsl"],
+    handler: (sdk, input) => sdk.parseGraphDsl(String(input.source ?? input.query ?? ""))
+  },
+  {
+    name: "resolveReference",
+    aliases: ["resolve-reference"],
+    handler: (sdk, input) => sdk.resolveReference(String(input.reference ?? ""), input.options)
+  },
+  {
+    name: "explainReferenceChain",
+    aliases: ["explain-reference-chain"],
+    handler: (sdk, input) => sdk.explainReferenceChain(String(input.fromId ?? ""), String(input.toId ?? ""))
+  }
+];
+const SDK_OPERATION_INDEX = /* @__PURE__ */ new Map();
+for (const spec of SDK_OPERATION_SPECS) {
+  SDK_OPERATION_INDEX.set(spec.name, spec);
+  for (const alias of spec.aliases ?? []) {
+    SDK_OPERATION_INDEX.set(alias, spec);
+  }
+}
+function listSdkOperationNames() {
+  return [...new Set(SDK_OPERATION_SPECS.map((entry) => entry.name))];
+}
+function findSdkOperation(name) {
+  return SDK_OPERATION_INDEX.get(name) ?? null;
+}
+function resolveSdkInstance(sharedSdk, config, request) {
+  if (!request.repoRoot || request.repoRoot === config.repoRoot) {
+    return sharedSdk ?? new AgentSdkClass({ repoRoot: config.repoRoot });
+  }
+  return new AgentSdkClass({ repoRoot: request.repoRoot });
+}
+async function executeSdkOperation(sdk, operationName, input) {
+  const spec = findSdkOperation(operationName);
+  if (!spec) {
+    throw new Error(`Unknown SDK operation "${operationName}".`);
+  }
+  return await spec.handler(sdk, input);
+}
+export {
+  executeSdkOperation,
+  findSdkOperation,
+  listSdkOperationNames,
+  resolveSdkInstance
+};

package/dist/api/sdk-routes.d.ts

@@ -0,0 +1,10 @@
+import type { Hono } from 'hono';
+import type { AgentSdk } from '@treeseed/sdk';
+import type { ApiConfig } from './types.ts';
+interface RegisterSdkRoutesOptions {
+    config: ApiConfig;
+    sharedSdk?: AgentSdk;
+    scope: string;
+}
+export declare function registerSdkRoutes(app: Hono<any>, options: RegisterSdkRoutesOptions): void;
+export {};

package/dist/api/sdk-routes.js

@@ -0,0 +1,25 @@
+import { executeSdkOperation, resolveSdkInstance } from "./sdk-dispatch.js";
+import { jsonError, requireScope } from "./http.js";
+function registerSdkRoutes(app, options) {
+  app.post("/sdk/:operation", async (c) => {
+    const unauthorized = requireScope(c, options.scope);
+    if (unauthorized) return unauthorized;
+    const operation = c.req.param("operation");
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      const result = await executeSdkOperation(
+        resolveSdkInstance(options.sharedSdk, options.config, body),
+        operation,
+        body.input ?? {}
+      );
+      return c.json(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = /Unknown SDK operation/.test(message) ? 400 : 500;
+      return jsonError(c, status, message, { operation });
+    }
+  });
+}
+export {
+  registerSdkRoutes
+};

package/dist/api/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/api/server.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { createRailwayTreeseedApiServer } from "./railway.js";
+const currentFile = fileURLToPath(import.meta.url);
+const entryFile = process.argv[1] ?? "";
+if (entryFile === currentFile) {
+  const instance = await createRailwayTreeseedApiServer();
+  process.stdout.write(`Treeseed API listening on ${instance.url}
+`);
+}

package/dist/api/templates.d.ts

@@ -0,0 +1,3 @@
+import type { SdkTemplateCatalogResponse } from '@treeseed/sdk/types';
+import type { ApiConfig } from './types.ts';
+export declare function loadTemplateCatalog(config: ApiConfig): SdkTemplateCatalogResponse;

package/dist/api/templates.js

@@ -0,0 +1,31 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { parseTemplateCatalogResponse } from "@treeseed/sdk/template-catalog";
+const require2 = createRequire(import.meta.url);
+function resolveSdkPackageRoot() {
+  const exportedEntrypoint = require2.resolve("@treeseed/sdk");
+  const distRoot = dirname(exportedEntrypoint);
+  const packageRoot = resolve(distRoot, "..");
+  return packageRoot;
+}
+function resolveDefaultCatalogPath() {
+  const sdkRoot = resolveSdkPackageRoot();
+  const candidates = [
+    resolve(sdkRoot, "dist", "treeseed", "template-catalog", "catalog.fixture.json"),
+    resolve(sdkRoot, "src", "treeseed", "template-catalog", "catalog.fixture.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error("Unable to resolve the bundled Treeseed template catalog fixture.");
+}
+function loadTemplateCatalog(config) {
+  const catalogPath = config.templateCatalogPath ?? resolveDefaultCatalogPath();
+  return parseTemplateCatalogResponse(JSON.parse(readFileSync(catalogPath, "utf8")));
+}
+export {
+  loadTemplateCatalog
+};