@treeseed/core 0.8.3 → 0.8.4

package/dist/agents/adapters/execution.js

@@ -1,73 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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;
-        changedPaths: string[];
-    }>;
-}

package/dist/agents/adapters/mutations.js

@@ -1,30 +0,0 @@
-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

@@ -1,26 +0,0 @@
-import type { AgentNotificationAdapter } from '../runtime-types.ts';
-export declare class StubNotificationAdapter implements AgentNotificationAdapter {
-    deliver(input: {
-        recipients: string[];
-    }): Promise<{
-        status: "completed" | "waiting";
-        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

@@ -1,46 +0,0 @@
-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

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

package/dist/agents/adapters/repository.js

@@ -1,61 +0,0 @@
-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
-};

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

@@ -1,26 +0,0 @@
-import type { AgentResearchAdapter } from '../runtime-types.ts';
-export declare class StubResearchAdapter implements AgentResearchAdapter {
-    research(input: {
-        questionId: string;
-        reason: string | null;
-        runId: string;
-    }): Promise<{
-        status: "completed";
-        summary: string;
-        markdown: string;
-        sources: any[];
-    }>;
-}
-export declare class ProjectGraphResearchAdapter implements AgentResearchAdapter {
-    research(input: {
-        questionId: string;
-        reason: string | null;
-        runId: string;
-    }): Promise<{
-        status: "completed";
-        summary: string;
-        markdown: string;
-        sources: any;
-    }>;
-}
-export declare function createResearchAdapter(): StubResearchAdapter | ProjectGraphResearchAdapter;

package/dist/agents/adapters/research.js

@@ -1,59 +0,0 @@
-import { AgentSdk } from "@treeseed/sdk";
-import { resolveTreeseedTenantRoot } from "@treeseed/sdk/platform/tenant-config";
-import { getTreeseedAgentProviderSelections } from "@treeseed/sdk/platform/deploy-runtime";
-class StubResearchAdapter {
-  async research(input) {
-    return {
-      status: "completed",
-      summary: `Research prepared for ${input.questionId}.`,
-      markdown: [
-        "# Research Summary",
-        "",
-        `Question: ${input.questionId}`,
-        `Reason: ${input.reason ?? "not provided"}`,
-        `Run: ${input.runId}`,
-        "",
-        "This is a stub research summary produced by the runtime adapter."
-      ].join("\n"),
-      sources: []
-    };
-  }
-}
-class ProjectGraphResearchAdapter {
-  async research(input) {
-    const repoRoot = resolveTreeseedTenantRoot();
-    const sdk = AgentSdk.createLocal({ repoRoot });
-    const graphResult = await sdk.queryGraph({
-      query: input.questionId,
-      options: {
-        limit: 5
-      }
-    }).catch(() => null);
-    const items = Array.isArray(graphResult?.items) ? graphResult.items : [];
-    return {
-      status: "completed",
-      summary: `Graph-backed research prepared for ${input.questionId}.`,
-      markdown: [
-        "# Research Summary",
-        "",
-        `Question: ${input.questionId}`,
-        `Reason: ${input.reason ?? "not provided"}`,
-        `Run: ${input.runId}`,
-        "",
-        items.length ? "Relevant graph context:" : "No ranked graph context was available. The question is still recorded for follow-up.",
-        ...items.map((item) => `- ${String(item.title ?? item.id ?? "context")}`)
-      ].join("\n"),
-      sources: items.map((item) => String(item.id ?? item.title ?? "")).filter(Boolean)
-    };
-  }
-}
-function createResearchAdapter() {
-  return String(
-    process.env.TREESEED_AGENT_RESEARCH_PROVIDER ?? getTreeseedAgentProviderSelections().research
-  ).toLowerCase() === "project_graph" ? new ProjectGraphResearchAdapter() : new StubResearchAdapter();
-}
-export {
-  ProjectGraphResearchAdapter,
-  StubResearchAdapter,
-  createResearchAdapter
-};

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

@@ -1,36 +0,0 @@
-import type { AgentVerificationAdapter } from '../runtime-types.ts';
-export declare class StubVerificationAdapter implements AgentVerificationAdapter {
-    runChecks(input: {
-        commands: string[];
-        runId: string;
-    }): Promise<{
-        status: "completed";
-        summary: string;
-        stdout: string;
-        stderr: string;
-    }>;
-}
-export declare class LocalVerificationAdapter implements AgentVerificationAdapter {
-    runChecks(input: {
-        commands: string[];
-    }): Promise<{
-        status: "waiting";
-        summary: string;
-        stdout: string;
-        stderr: string;
-        errorCategory?: undefined;
-    } | {
-        status: "failed";
-        summary: string;
-        stdout: string;
-        stderr: string;
-        errorCategory: "execution_error";
-    } | {
-        status: "completed";
-        summary: string;
-        stdout: string;
-        stderr: string;
-        errorCategory?: undefined;
-    }>;
-}
-export declare function createVerificationAdapter(): StubVerificationAdapter | LocalVerificationAdapter;

package/dist/agents/adapters/verification.js

@@ -1,62 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { getTreeseedAgentProviderSelections } from "@treeseed/sdk/platform/deploy-runtime";
-const execFileAsync = promisify(execFile);
-class StubVerificationAdapter {
-  async runChecks(input) {
-    return {
-      status: "completed",
-      summary: input.commands.length ? `Stub verification completed for ${input.runId}.` : "No verification commands configured.",
-      stdout: input.commands.join("\n"),
-      stderr: ""
-    };
-  }
-}
-class LocalVerificationAdapter {
-  async runChecks(input) {
-    if (!input.commands.length) {
-      return {
-        status: "waiting",
-        summary: "No verification commands configured.",
-        stdout: "",
-        stderr: ""
-      };
-    }
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    for (const command of input.commands) {
-      try {
-        const { stdout, stderr } = await execFileAsync("/bin/bash", ["-lc", command], {
-          env: process.env,
-          maxBuffer: 10 * 1024 * 1024
-        });
-        stdoutChunks.push(stdout);
-        stderrChunks.push(stderr);
-      } catch (error) {
-        return {
-          status: "failed",
-          summary: `Verification command failed: ${command}`,
-          stdout: stdoutChunks.join("\n"),
-          stderr: error && typeof error === "object" && "stderr" in error ? String(error.stderr ?? "") : String(error),
-          errorCategory: "execution_error"
-        };
-      }
-    }
-    return {
-      status: "completed",
-      summary: `Verification completed for ${input.commands.length} command(s).`,
-      stdout: stdoutChunks.join("\n"),
-      stderr: stderrChunks.join("\n")
-    };
-  }
-}
-function createVerificationAdapter() {
-  return String(
-    process.env.TREESEED_AGENT_VERIFICATION_PROVIDER ?? getTreeseedAgentProviderSelections().verification
-  ).toLowerCase() !== "local" ? new StubVerificationAdapter() : new LocalVerificationAdapter();
-}
-export {
-  LocalVerificationAdapter,
-  StubVerificationAdapter,
-  createVerificationAdapter
-};

package/dist/agents/cli-tools.d.ts

@@ -1 +0,0 @@
-export { normalizeAgentCliOptions, buildCopilotAllowToolArgs } from '@treeseed/sdk/cli-tools';

package/dist/agents/cli-tools.js

@@ -1,5 +0,0 @@
-import { normalizeAgentCliOptions, buildCopilotAllowToolArgs } from "@treeseed/sdk/cli-tools";
-export {
-  buildCopilotAllowToolArgs,
-  normalizeAgentCliOptions
-};

package/dist/agents/cli.d.ts

@@ -1,15 +0,0 @@
-export type TreeseedAgentCliCommandName = 'doctor' | 'run-agent' | 'drain-messages' | 'release-leases' | 'replay-message' | 'start';
-export type TreeseedAgentCliCommandSpec = {
-    name: TreeseedAgentCliCommandName;
-    usage: string;
-    summary: string;
-};
-export type TreeseedAgentCliContext = {
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    write?: (output: string, stream?: 'stdout' | 'stderr') => void;
-    outputFormat?: 'human' | 'json';
-};
-export declare function listTreeseedAgentCommands(): TreeseedAgentCliCommandSpec[];
-export declare function renderTreeseedAgentHelp(): string;
-export declare function runTreeseedAgentCli(argv: string[], context?: TreeseedAgentCliContext): Promise<number>;

package/dist/agents/cli.js

@@ -1,109 +0,0 @@
-import { realpathSync } from "node:fs";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-const AGENT_COMMAND_SPECS = [
-  { name: "doctor", usage: "doctor", summary: "Inspect agent runtime readiness for the current tenant." },
-  { name: "run-agent", usage: "run-agent <slug>", summary: "Run one registered agent handler by slug." },
-  { name: "drain-messages", usage: "drain-messages", summary: "Drain queued agent messages through the local kernel." },
-  { name: "release-leases", usage: "release-leases", summary: "Release active task leases held by the local kernel." },
-  { name: "replay-message", usage: "replay-message <id>", summary: "Replay one message by numeric id." },
-  { name: "start", usage: "start", summary: "Start the local agent kernel loop." }
-];
-function parseArgs(argv) {
-  const [command = "doctor", ...rest] = argv;
-  return {
-    command,
-    args: rest
-  };
-}
-function listTreeseedAgentCommands() {
-  return [...AGENT_COMMAND_SPECS];
-}
-function renderTreeseedAgentHelp() {
-  return [
-    "treeseed agents <command>",
-    "",
-    "Commands:",
-    ...AGENT_COMMAND_SPECS.map((command) => `  ${command.usage.padEnd(24)}${command.summary}`)
-  ].join("\n");
-}
-function defaultWrite(output, stream = "stdout") {
-  if (!output) return;
-  (stream === "stderr" ? process.stderr : process.stdout).write(`${output}
-`);
-}
-function resolveExecutablePath(path) {
-  try {
-    return realpathSync(path);
-  } catch {
-    return resolve(path);
-  }
-}
-async function runTreeseedAgentCli(argv, context = {}) {
-  const { command, args } = parseArgs(argv);
-  const write = context.write ?? defaultWrite;
-  if (command === "--help" || command === "-h" || command === "help") {
-    write(renderTreeseedAgentHelp(), "stdout");
-    return 0;
-  }
-  const [{ AgentKernel }, { AgentSdk }] = await Promise.all([
-    import("./kernel/agent-kernel.js"),
-    import("@treeseed/sdk/sdk")
-  ]);
-  const repoRoot = context.cwd ?? process.cwd();
-  const env = { ...process.env, ...context.env ?? {} };
-  const sdk = AgentSdk.createLocal({
-    repoRoot,
-    databaseName: env.TREESEED_AGENT_D1_DATABASE ?? "karyon-docs-site-data",
-    persistTo: env.TREESEED_AGENT_D1_PERSIST_TO ?? void 0
-  });
-  const kernel = new AgentKernel(sdk, repoRoot);
-  const emitPayload = async (payload) => {
-    write(JSON.stringify(await payload, null, 2), "stdout");
-    return 0;
-  };
-  if (command === "doctor") {
-    return emitPayload({ ok: true, command, ...await kernel.doctor() });
-  }
-  if (command === "run-agent") {
-    return emitPayload({ ok: true, command, slug: args[0], result: await kernel.runAgent(args[0]) });
-  }
-  if (command === "drain-messages") {
-    return emitPayload({ ok: true, command, results: await kernel.drainMessages() });
-  }
-  if (command === "release-leases") {
-    return emitPayload({ ok: true, command, result: await kernel.releaseLeases() });
-  }
-  if (command === "replay-message") {
-    return emitPayload({ ok: true, command, result: await kernel.replayMessage(Number(args[0])) });
-  }
-  if (command === "start") {
-    write(JSON.stringify({ ok: true, command, status: "starting" }, null, 2), "stdout");
-    await kernel.start();
-    return 0;
-  }
-  throw new Error(`Unknown Treeseed command "${command}".`);
-}
-const currentFile = resolveExecutablePath(fileURLToPath(import.meta.url));
-const entryFile = resolveExecutablePath(process.argv[1] ?? "");
-if (entryFile === currentFile) {
-  runTreeseedAgentCli(process.argv.slice(2)).catch((error) => {
-    defaultWrite(
-      JSON.stringify(
-        {
-          ok: false,
-          error: error instanceof Error ? error.message : String(error)
-        },
-        null,
-        2
-      ),
-      "stderr"
-    );
-    process.exit(1);
-  });
-}
-export {
-  listTreeseedAgentCommands,
-  renderTreeseedAgentHelp,
-  runTreeseedAgentCli
-};