@treeseed/agent 0.8.5

package/Dockerfile

@@ -0,0 +1,7 @@
+FROM node:22-bookworm-slim
+
+WORKDIR /app
+
+COPY . .
+
+ENTRYPOINT ["node", "./dist/scripts/treeseed-agents.js", "start"]

package/README.md

@@ -0,0 +1,198 @@
+# `@treeseed/agent`
+
+Treeseed agent service runtime package.
+
+This package publishes the `treeseed-agents` CLI, the shared runtime exports for TreeSeed agents, and the Node service entrypoints used by the unified agent-hosting system.
+
+## What It Provides
+
+- the existing `treeseed-agents` CLI for local runtime inspection and execution
+- `manager` for work-day orchestration, graph ownership, and context assembly
+- `worker` for bounded task execution against Cloudflare Queue deliveries
+- `workday-start` and `workday-report` for cron-friendly kickoff and reporting
+- helper scripts for running a local manager against a deployed Cloudflare site and gateway
+
+## Deployment Shapes
+
+This package supports three useful shapes:
+
+1. Fully local
+2. Cloudflare site + local manager on your laptop
+3. Cloudflare control plane + Railway manager/worker services
+
+The hybrid laptop-manager flow is explicitly supported. The manager is just a Node process and can talk to a deployed Cloudflare gateway and queue as long as the right env vars are set.
+
+## Requirements
+
+- Node `>=22`
+- npm
+- a Treeseed tenant repository for runtime commands such as `doctor` and `start`
+
+## Install
+
+```bash
+npm install @treeseed/agent @treeseed/sdk
+```
+
+## Build And Test
+
+```bash
+npm install
+npm run build
+npm test
+npm run release:verify
+```
+
+`npm test` runs the package smoke test. `npm run release:verify` rebuilds the package, runs the smoke test, and verifies that the packed tarball installs cleanly with the published `treeseed-agents` binary.
+
+`npm test` currently validates the legacy smoke path. For the new hosting stack, the minimum package-local verification is:
+
+```bash
+npm run build
+npm run dev:manager
+```
+
+and, when configured:
+
+```bash
+npm run dev:worker
+npm run dev:workday-start
+npm run dev:workday-report
+```
+
+## CLI
+
+Run the CLI from a Treeseed tenant repository root, or set `TREESEED_TENANT_ROOT` to point at one.
+
+```bash
+treeseed-agents doctor
+treeseed-agents run-agent planner-agent
+treeseed-agents start
+```
+
+Available commands:
+
+- `doctor`
+- `run-agent <slug>`
+- `drain-messages`
+- `release-leases`
+- `replay-message <id>`
+- `start`
+
+## Service Commands
+
+Development entrypoints:
+
+- `npm run dev:manager`
+- `npm run dev:worker`
+- `npm run dev:workday-start`
+- `npm run dev:workday-report`
+
+Built entrypoints:
+
+- `npm run start:manager`
+- `npm run start:worker`
+- `npm run start:workday-start`
+- `npm run start:workday-report`
+
+Hybrid convenience entrypoint:
+
+- `npm run start:local-manager-cloudflare`
+
+## Local Manager With Cloudflare
+
+Use this when:
+
+- your site is deployed on Cloudflare
+- your gateway Worker is deployed on Cloudflare
+- you want the agent manager running on your laptop instead of Railway
+
+Setup:
+
+```bash
+cp .env.local-manager-cloudflare.example .env.local-manager-cloudflare
+```
+
+Required values:
+
+- `TREESEED_AGENT_REPO_ROOT`
+- `TREESEED_GATEWAY_BASE_URL`
+- `TREESEED_GATEWAY_BEARER_TOKEN`
+- `CLOUDFLARE_ACCOUNT_ID`
+- `TREESEED_QUEUE_ID`
+
+If you also want a local worker, set:
+
+- `TREESEED_QUEUE_PULL_TOKEN`
+
+Start the manager:
+
+```bash
+npm run start:local-manager-cloudflare
+```
+
+Start a local worker in another shell:
+
+```bash
+set -a; source ./.env.local-manager-cloudflare; set +a
+npm run dev:worker
+```
+
+Kick off the work day:
+
+```bash
+set -a; source ./.env.local-manager-cloudflare; set +a
+npm run dev:workday-start
+```
+
+Generate the report:
+
+```bash
+set -a; source ./.env.local-manager-cloudflare; set +a
+npm run dev:workday-report
+```
+
+## Environment
+
+Common runtime variables:
+
+- `TREESEED_AGENT_REPO_ROOT`
+- `TREESEED_AGENT_D1_DATABASE`
+- `TREESEED_AGENT_D1_PERSIST_TO`
+- `TREESEED_PROJECT_ID`
+- `TREESEED_WORKDAY_CAPACITY_BUDGET`
+- `TREESEED_GATEWAY_BASE_URL`
+- `TREESEED_GATEWAY_BEARER_TOKEN`
+- `TREESEED_MANAGER_BASE_URL`
+- `TREESEED_WORKER_ID`
+- `TREESEED_QUEUE_BATCH_SIZE`
+- `TREESEED_QUEUE_VISIBILITY_TIMEOUT_MS`
+- `TREESEED_TASK_LEASE_SECONDS`
+- `TREESEED_WORKER_POLL_INTERVAL_MS`
+- `CLOUDFLARE_ACCOUNT_ID`
+- `TREESEED_QUEUE_ID`
+- `TREESEED_QUEUE_PULL_TOKEN`
+
+## Package Scripts
+
+- `npm run setup`: install dependencies with `npm install`
+- `npm run setup:ci`: install dependencies with `npm ci`
+- `npm run build`: build the distributable package
+- `npm run dev:manager`: run the manager directly from source
+- `npm run dev:worker`: run the worker directly from source
+- `npm run dev:workday-start`: run the cron-style start entrypoint directly from source
+- `npm run dev:workday-report`: run the cron-style report entrypoint directly from source
+- `npm run start:manager`: run the built manager
+- `npm run start:worker`: run the built worker
+- `npm run start:workday-start`: run the built workday-start entrypoint
+- `npm run start:workday-report`: run the built workday-report entrypoint
+- `npm run start:local-manager-cloudflare`: load the local-manager env file and start the built manager
+- `npm test`: run the smoke test
+- `npm run release:verify`: verify build, smoke test, and packed-install behavior
+- `npm run release:check-tag -- <tag>`: validate plain semver tags like `0.1.1` against `package.json`
+- `npm run release:publish`: publish to npm
+
+## GitHub Actions
+
+- `.github/workflows/ci.yml` runs `npm ci`, `npm run build`, `npm test`, and `npm run release:verify` on pushes and pull requests.
+- `.github/workflows/publish.yml` runs the same verification steps before publishing on `*.*.*` version tags or manual dispatch.

package/dist/agent-runtime.d.ts

@@ -0,0 +1,17 @@
+import type { AgentExecutionAdapter, AgentHandler, AgentMutationAdapter, AgentNotificationAdapter, AgentRepositoryInspectionAdapter, AgentResearchAdapter, AgentVerificationAdapter } from './agents/runtime-types.ts';
+export declare function resolveAgentRuntimeProviders(repoRoot: string, selections: {
+    execution: string;
+    mutation: string;
+    repository: string;
+    verification: string;
+    notification: string;
+    research: string;
+}): {
+    execution: AgentExecutionAdapter;
+    mutations: AgentMutationAdapter;
+    repository: AgentRepositoryInspectionAdapter;
+    verification: AgentVerificationAdapter;
+    notifications: AgentNotificationAdapter;
+    research: AgentResearchAdapter;
+    handlers: Map<string, AgentHandler<unknown, unknown>>;
+};

package/dist/agent-runtime.js

@@ -0,0 +1,117 @@
+import { loadTreeseedPluginRuntime } from "@treeseed/sdk/platform/plugins";
+import {
+  CopilotExecutionAdapter,
+  ManualExecutionAdapter,
+  StubExecutionAdapter
+} from "./agents/adapters/execution.js";
+import { LocalBranchMutationAdapter } from "./agents/adapters/mutations.js";
+import { SdkMessageNotificationAdapter, StubNotificationAdapter } from "./agents/adapters/notification.js";
+import { GitRepositoryInspectionAdapter, StubRepositoryInspectionAdapter } from "./agents/adapters/repository.js";
+import { ProjectGraphResearchAdapter, StubResearchAdapter } from "./agents/adapters/research.js";
+import { LocalVerificationAdapter, StubVerificationAdapter } from "./agents/adapters/verification.js";
+let cachedAgentRuntime = null;
+function readPluginRecord(pluginEntry, key) {
+  const value = pluginEntry.plugin[key];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function assertUniqueProvider(registry, id, owner) {
+  if (registry.has(id)) {
+    throw new Error(`Treeseed plugin runtime found duplicate provider "${id}" from ${owner}.`);
+  }
+}
+function collectAgentHandlersFromPlugin(pluginEntry, registry) {
+  const contributedHandlers = readPluginRecord(pluginEntry, "agentHandlers");
+  for (const [id, handler] of Object.entries(contributedHandlers)) {
+    assertUniqueProvider(registry, id, pluginEntry.package);
+    registry.set(id, handler);
+  }
+}
+function buildAgentRuntime() {
+  const runtime = loadTreeseedPluginRuntime();
+  const execution = /* @__PURE__ */ new Map([
+    ["stub", () => new StubExecutionAdapter()],
+    ["manual", () => new ManualExecutionAdapter()],
+    ["copilot", () => new CopilotExecutionAdapter()]
+  ]);
+  const mutation = /* @__PURE__ */ new Map([
+    ["local_branch", (repoRoot) => new LocalBranchMutationAdapter(repoRoot)]
+  ]);
+  const repository = /* @__PURE__ */ new Map([
+    ["stub", () => new StubRepositoryInspectionAdapter()],
+    ["git", () => new GitRepositoryInspectionAdapter()]
+  ]);
+  const verification = /* @__PURE__ */ new Map([
+    ["stub", () => new StubVerificationAdapter()],
+    ["local", () => new LocalVerificationAdapter()]
+  ]);
+  const notification = /* @__PURE__ */ new Map([
+    ["stub", () => new StubNotificationAdapter()],
+    ["sdk_message", () => new SdkMessageNotificationAdapter()]
+  ]);
+  const research = /* @__PURE__ */ new Map([
+    ["stub", () => new StubResearchAdapter()],
+    ["project_graph", () => new ProjectGraphResearchAdapter()]
+  ]);
+  const handlers = /* @__PURE__ */ new Map();
+  for (const pluginEntry of runtime.plugins) {
+    const agentProviders = readPluginRecord(pluginEntry, "agentProviders");
+    for (const [id, factory] of Object.entries(agentProviders.execution ?? {})) {
+      assertUniqueProvider(execution, id, pluginEntry.package);
+      execution.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(agentProviders.mutation ?? {})) {
+      assertUniqueProvider(mutation, id, pluginEntry.package);
+      mutation.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(agentProviders.repository ?? {})) {
+      assertUniqueProvider(repository, id, pluginEntry.package);
+      repository.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(agentProviders.verification ?? {})) {
+      assertUniqueProvider(verification, id, pluginEntry.package);
+      verification.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(agentProviders.notification ?? {})) {
+      assertUniqueProvider(notification, id, pluginEntry.package);
+      notification.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(agentProviders.research ?? {})) {
+      assertUniqueProvider(research, id, pluginEntry.package);
+      research.set(id, factory);
+    }
+    collectAgentHandlersFromPlugin(pluginEntry, handlers);
+  }
+  return {
+    providers: { execution, mutation, repository, verification, notification, research },
+    handlers
+  };
+}
+function resolveAgentRuntimeProviders(repoRoot, selections) {
+  if (!cachedAgentRuntime) {
+    cachedAgentRuntime = buildAgentRuntime();
+  }
+  const executionFactory = cachedAgentRuntime.providers.execution.get(selections.execution);
+  const mutationFactory = cachedAgentRuntime.providers.mutation.get(selections.mutation);
+  const repositoryFactory = cachedAgentRuntime.providers.repository.get(selections.repository);
+  const verificationFactory = cachedAgentRuntime.providers.verification.get(selections.verification);
+  const notificationFactory = cachedAgentRuntime.providers.notification.get(selections.notification);
+  const researchFactory = cachedAgentRuntime.providers.research.get(selections.research);
+  if (!executionFactory) throw new Error(`Treeseed agent execution provider "${selections.execution}" is not registered.`);
+  if (!mutationFactory) throw new Error(`Treeseed agent mutation provider "${selections.mutation}" is not registered.`);
+  if (!repositoryFactory) throw new Error(`Treeseed agent repository provider "${selections.repository}" is not registered.`);
+  if (!verificationFactory) throw new Error(`Treeseed agent verification provider "${selections.verification}" is not registered.`);
+  if (!notificationFactory) throw new Error(`Treeseed agent notification provider "${selections.notification}" is not registered.`);
+  if (!researchFactory) throw new Error(`Treeseed agent research provider "${selections.research}" is not registered.`);
+  return {
+    execution: executionFactory(),
+    mutations: mutationFactory(repoRoot),
+    repository: repositoryFactory(),
+    verification: verificationFactory(),
+    notifications: notificationFactory(),
+    research: researchFactory(),
+    handlers: cachedAgentRuntime.handlers
+  };
+}
+export {
+  resolveAgentRuntimeProviders
+};

package/dist/agents/adapters/execution.d.ts

@@ -0,0 +1,41 @@
+import type { AgentExecutionAdapter } from '../runtime-types.ts';
+export declare class StubExecutionAdapter implements AgentExecutionAdapter {
+    runTask(input: {
+        prompt: string;
+        runId: string;
+    }): Promise<{
+        status: "completed";
+        summary: string;
+        stdout: string;
+        stderr: string;
+    }>;
+}
+export declare class CopilotExecutionAdapter implements AgentExecutionAdapter {
+    runTask(input: {
+        agent: {
+            cli?: {
+                model?: string;
+                allowTools?: string[];
+                additionalArgs?: string[];
+            };
+        };
+        prompt: string;
+    }): Promise<{
+        stderr: string;
+        status: "completed" | "failed";
+        summary: string;
+        stdout: string;
+    }>;
+}
+export declare class ManualExecutionAdapter implements AgentExecutionAdapter {
+    runTask(input: {
+        prompt: string;
+        runId: string;
+    }): Promise<{
+        status: "completed";
+        summary: string;
+        stdout: string;
+        stderr: string;
+    }>;
+}
+export declare function createExecutionAdapter(): StubExecutionAdapter | CopilotExecutionAdapter | ManualExecutionAdapter;

package/dist/agents/adapters/execution.js

@@ -0,0 +1,73 @@
+import { normalizeAgentCliOptions } from "../cli-tools.js";
+import { getTreeseedAgentProviderSelections } from "@treeseed/sdk/platform/deploy-runtime";
+import { runTreeseedCopilotTask } from "@treeseed/sdk/copilot";
+class StubExecutionAdapter {
+  async runTask(input) {
+    return {
+      status: "completed",
+      summary: `Stubbed Copilot execution for ${input.runId}.`,
+      stdout: [
+        "# Planned Task",
+        "",
+        "1. Inspect the requested architecture context.",
+        "2. Produce a safe local change artifact.",
+        "3. Summarize the implementation intent.",
+        "",
+        `Prompt digest: ${input.prompt.slice(0, 240)}`
+      ].join("\n"),
+      stderr: ""
+    };
+  }
+}
+class CopilotExecutionAdapter {
+  async runTask(input) {
+    const cli = normalizeAgentCliOptions(input.agent.cli);
+    const result = await runTreeseedCopilotTask({
+      prompt: input.prompt,
+      cwd: process.cwd(),
+      model: cli.model,
+      allowTools: cli.allowTools,
+      env: process.env
+    });
+    const ignoredArgs = cli.additionalArgs?.length ? `Ignored Copilot CLI-only arguments because Treeseed uses @github/copilot-sdk internally: ${cli.additionalArgs.join(" ")}` : "";
+    return {
+      ...result,
+      stderr: [result.stderr, ignoredArgs].filter(Boolean).join("\n")
+    };
+  }
+}
+class ManualExecutionAdapter {
+  async runTask(input) {
+    return {
+      status: "completed",
+      summary: `Manual execution mode is enabled for ${input.runId}.`,
+      stdout: [
+        "# Manual Execution Required",
+        "",
+        "This agent run is configured for manual execution.",
+        "Review the prompt below and complete the work outside the automated adapter.",
+        "",
+        input.prompt
+      ].join("\n"),
+      stderr: ""
+    };
+  }
+}
+function createExecutionAdapter() {
+  const configuredMode = String(
+    process.env.TREESEED_AGENT_EXECUTION_PROVIDER ?? getTreeseedAgentProviderSelections().execution
+  ).toLowerCase();
+  if (configuredMode === "manual") {
+    return new ManualExecutionAdapter();
+  }
+  if (configuredMode !== "copilot") {
+    return new StubExecutionAdapter();
+  }
+  return new CopilotExecutionAdapter();
+}
+export {
+  CopilotExecutionAdapter,
+  ManualExecutionAdapter,
+  StubExecutionAdapter,
+  createExecutionAdapter
+};

package/dist/agents/adapters/mutations.d.ts

@@ -0,0 +1,22 @@
+import type { AgentMutationAdapter } from '../runtime-types.ts';
+export declare class LocalBranchMutationAdapter implements AgentMutationAdapter {
+    private readonly git;
+    constructor(repoRoot: string);
+    writeArtifact(input: {
+        runId: string;
+        agent: {
+            execution: {
+                branchPrefix: string;
+            };
+        };
+        relativePath: string;
+        content: string;
+        commitMessage: string;
+    }): Promise<{
+        branchName: string;
+        commitMessage: string;
+        worktreePath: string;
+        commitSha: string | null;
+        changedPaths: string[];
+    }>;
+}

package/dist/agents/adapters/mutations.js

@@ -0,0 +1,30 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { GitRuntime } from "@treeseed/sdk/git-runtime";
+class LocalBranchMutationAdapter {
+  git;
+  constructor(repoRoot) {
+    this.git = new GitRuntime(
+      repoRoot,
+      process.env.TREESEED_AGENT_DISABLE_GIT === "true"
+    );
+  }
+  async writeArtifact(input) {
+    const branchName = `${input.agent.execution.branchPrefix}/${input.runId}`;
+    const worktreePath = await this.git.ensureWorktree(branchName);
+    const filePath = path.join(worktreePath, input.relativePath);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, input.content, "utf8");
+    const git = await this.git.commitFileChange(filePath, branchName, input.commitMessage);
+    return {
+      branchName: git.branchName,
+      commitMessage: git.commitMessage,
+      worktreePath: git.worktreePath,
+      commitSha: git.commitSha,
+      changedPaths: git.changedPaths
+    };
+  }
+}
+export {
+  LocalBranchMutationAdapter
+};

package/dist/agents/adapters/notification.d.ts

@@ -0,0 +1,26 @@
+import type { AgentNotificationAdapter } from '../runtime-types.ts';
+export declare class StubNotificationAdapter implements AgentNotificationAdapter {
+    deliver(input: {
+        recipients: string[];
+    }): Promise<{
+        status: "waiting" | "completed";
+        summary: string;
+        deliveredCount: number;
+    }>;
+}
+export declare class SdkMessageNotificationAdapter implements AgentNotificationAdapter {
+    deliver(input: {
+        agent: {
+            slug: string;
+        };
+        runId: string;
+        recipients: string[];
+        subject: string;
+        body: string;
+    }): Promise<{
+        status: "completed";
+        summary: string;
+        deliveredCount: number;
+    }>;
+}
+export declare function createNotificationAdapter(): StubNotificationAdapter | SdkMessageNotificationAdapter;

package/dist/agents/adapters/notification.js

@@ -0,0 +1,46 @@
+import { AgentSdk } from "@treeseed/sdk";
+import { resolveTreeseedTenantRoot } from "@treeseed/sdk/platform/tenant-config";
+import { getTreeseedAgentProviderSelections } from "@treeseed/sdk/platform/deploy-runtime";
+class StubNotificationAdapter {
+  async deliver(input) {
+    return {
+      status: input.recipients.length ? "completed" : "waiting",
+      summary: input.recipients.length ? `Prepared ${input.recipients.length} notification(s).` : "No recipients available for notification.",
+      deliveredCount: input.recipients.length
+    };
+  }
+}
+class SdkMessageNotificationAdapter {
+  async deliver(input) {
+    const sdk = AgentSdk.createLocal({ repoRoot: resolveTreeseedTenantRoot() });
+    await sdk.createMessage({
+      type: "agent.notification",
+      payload: {
+        agentSlug: input.agent.slug,
+        runId: input.runId,
+        recipients: input.recipients,
+        subject: input.subject,
+        body: input.body,
+        summary: `Prepared ${input.recipients.length} notification(s).`
+      },
+      relatedModel: "agent",
+      relatedId: input.agent.slug,
+      actor: "agent"
+    });
+    return {
+      status: "completed",
+      summary: input.recipients.length ? `Prepared ${input.recipients.length} notification(s).` : "Notification recorded without recipients.",
+      deliveredCount: input.recipients.length
+    };
+  }
+}
+function createNotificationAdapter() {
+  return String(
+    process.env.TREESEED_AGENT_NOTIFICATION_PROVIDER ?? getTreeseedAgentProviderSelections().notification
+  ).toLowerCase() === "sdk_message" ? new SdkMessageNotificationAdapter() : new StubNotificationAdapter();
+}
+export {
+  SdkMessageNotificationAdapter,
+  StubNotificationAdapter,
+  createNotificationAdapter
+};

package/dist/agents/adapters/repository.d.ts

@@ -0,0 +1,28 @@
+import type { AgentRepositoryInspectionAdapter } from '../runtime-types.ts';
+export declare class StubRepositoryInspectionAdapter implements AgentRepositoryInspectionAdapter {
+    inspectBranch(input: {
+        branchName: string | null;
+    }): Promise<{
+        branchName: string | null;
+        changedPaths: never[];
+        commitSha: null;
+        summary: string;
+    }>;
+}
+export declare class GitRepositoryInspectionAdapter implements AgentRepositoryInspectionAdapter {
+    inspectBranch(input: {
+        repoRoot: string;
+        branchName: string | null;
+    }): Promise<{
+        branchName: null;
+        changedPaths: never[];
+        commitSha: null;
+        summary: string;
+    } | {
+        branchName: string;
+        changedPaths: string[];
+        commitSha: string | null;
+        summary: string;
+    }>;
+}
+export declare function createRepositoryInspectionAdapter(): StubRepositoryInspectionAdapter | GitRepositoryInspectionAdapter;

package/dist/agents/adapters/repository.js

@@ -0,0 +1,61 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { getTreeseedAgentProviderSelections } from "@treeseed/sdk/platform/deploy-runtime";
+const execFileAsync = promisify(execFile);
+class StubRepositoryInspectionAdapter {
+  async inspectBranch(input) {
+    return {
+      branchName: input.branchName,
+      changedPaths: [],
+      commitSha: null,
+      summary: input.branchName ? `Stub repository inspection for ${input.branchName}.` : "No branch to inspect."
+    };
+  }
+}
+class GitRepositoryInspectionAdapter {
+  async inspectBranch(input) {
+    if (!input.branchName) {
+      return {
+        branchName: null,
+        changedPaths: [],
+        commitSha: null,
+        summary: "No branch to inspect."
+      };
+    }
+    try {
+      const { stdout: changedStdout } = await execFileAsync(
+        "git",
+        ["diff", "--name-only", "HEAD~1..HEAD"],
+        { cwd: input.repoRoot, env: process.env }
+      );
+      const { stdout: shaStdout } = await execFileAsync("git", ["rev-parse", "HEAD"], {
+        cwd: input.repoRoot,
+        env: process.env
+      });
+      const changedPaths = changedStdout.split("\n").map((entry) => entry.trim()).filter(Boolean);
+      return {
+        branchName: input.branchName,
+        changedPaths,
+        commitSha: shaStdout.trim() || null,
+        summary: `Inspected ${changedPaths.length} changed path(s) on ${input.branchName}.`
+      };
+    } catch {
+      return {
+        branchName: input.branchName,
+        changedPaths: [],
+        commitSha: null,
+        summary: `Unable to inspect branch ${input.branchName}.`
+      };
+    }
+  }
+}
+function createRepositoryInspectionAdapter() {
+  return String(
+    process.env.TREESEED_AGENT_REPOSITORY_PROVIDER ?? getTreeseedAgentProviderSelections().repository
+  ).toLowerCase() !== "git" ? new StubRepositoryInspectionAdapter() : new GitRepositoryInspectionAdapter();
+}
+export {
+  GitRepositoryInspectionAdapter,
+  StubRepositoryInspectionAdapter,
+  createRepositoryInspectionAdapter
+};