@treeseed/agent 0.1.2

package/dist/scripts/release-verify.js

@@ -0,0 +1,143 @@
+import { cpSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync, existsSync } from 'node:fs';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, extname, join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { packageRoot } from './package-tools.js';
+const require = createRequire(import.meta.url);
+const corePackageRoot = resolve(dirname(require.resolve('@treeseed/core')), '..');
+const sdkPackageRoot = resolve(dirname(require.resolve('@treeseed/sdk')), '..');
+const textExtensions = new Set(['.js', '.ts', '.mjs', '.cjs', '.d.js', '.json', '.md']);
+const forbiddenPatterns = [
+    /['"`]file:[^'"`\n]+['"`]/,
+    /['"`]workspace:[^'"`\n]+['"`]/,
+    /['"`](?:\.\.\/|\.\/)[^'"`\n]*src\/[^'"`\n]*\.(?:[cm]?js|ts|tsx|json|astro|css)['"`]/,
+    /['"`][^'"`\n]*\/packages\/[^'"`\n]*\/src\/[^'"`\n]*['"`]/,
+];
+function run(command, args, cwd = packageRoot, capture = false) {
+    const result = spawnSync(command, args, {
+        cwd,
+        stdio: capture ? 'pipe' : 'inherit',
+        encoding: 'utf8',
+        env: process.env,
+    });
+    if (result.status !== 0) {
+        throw new Error(result.stderr?.trim() || result.stdout?.trim() || `${command} ${args.join(' ')} failed`);
+    }
+    return (result.stdout ?? '').trim();
+}
+function walkFiles(root) {
+    const files = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const fullPath = join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...walkFiles(fullPath));
+            continue;
+        }
+        files.push(fullPath);
+    }
+    return files;
+}
+function scanDirectory(root) {
+    for (const filePath of walkFiles(root)) {
+        if (!textExtensions.has(extname(filePath)))
+            continue;
+        const source = readFileSync(filePath, 'utf8');
+        for (const pattern of forbiddenPatterns) {
+            if (pattern.test(source)) {
+                throw new Error(`${filePath} contains forbidden publish reference matching ${pattern}.`);
+            }
+        }
+    }
+}
+function resolveNodeModulesRoot() {
+    let lastCandidate = null;
+    let current = packageRoot;
+    while (true) {
+        const candidate = resolve(current, 'node_modules');
+        try {
+            readdirSync(candidate);
+            lastCandidate = candidate;
+        }
+        catch {
+        }
+        const parent = resolve(current, '..');
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    if (lastCandidate) {
+        return lastCandidate;
+    }
+    throw new Error(`Unable to locate node_modules for ${packageRoot}.`);
+}
+function mirrorDependencies(tempRoot) {
+    const sharedNodeModules = resolveNodeModulesRoot();
+    for (const entry of readdirSync(sharedNodeModules, { withFileTypes: true })) {
+        if (entry.name === '.bin' || entry.name === '@treeseed') {
+            continue;
+        }
+        const targetPath = resolve(tempRoot, 'node_modules', entry.name);
+        mkdirSync(dirname(targetPath), { recursive: true });
+        symlinkSync(resolve(sharedNodeModules, entry.name), targetPath, 'dir');
+    }
+}
+function pack(root, fallbackName) {
+    const output = run('npm', ['pack', '--silent', '--ignore-scripts'], root, true);
+    const filename = output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .at(-1) ?? fallbackName;
+    return resolve(root, filename);
+}
+function installPackagedPackage(extractRoot, tempRoot, tarballPath, folderName) {
+    mkdirSync(resolve(tempRoot, 'node_modules', '@treeseed'), { recursive: true });
+    run('tar', ['-xzf', tarballPath, '-C', extractRoot]);
+    run('cp', ['-R', resolve(extractRoot, 'package'), resolve(tempRoot, 'node_modules', '@treeseed', folderName)]);
+    rmSync(resolve(extractRoot, 'package'), { recursive: true, force: true });
+}
+function isInstalledDependencyPackage(root) {
+    return root.includes(`${process.platform === 'win32' ? '\\' : '/'}node_modules${process.platform === 'win32' ? '\\' : '/'}`);
+}
+function installDependencyPackage(root, extractRoot, tempRoot, folderName, fallbackName) {
+    if (isInstalledDependencyPackage(root) && existsSync(resolve(root, 'dist')) && existsSync(resolve(root, 'package.json'))) {
+        const targetRoot = resolve(tempRoot, 'node_modules', '@treeseed', folderName);
+        mkdirSync(resolve(tempRoot, 'node_modules', '@treeseed'), { recursive: true });
+        cpSync(root, targetRoot, {
+            recursive: true,
+            filter(source) {
+                const relativePath = source.slice(root.length).replace(/^[/\\]/, '');
+                if (!relativePath) {
+                    return true;
+                }
+                return !(relativePath === 'node_modules'
+                    || relativePath.startsWith(`node_modules${process.platform === 'win32' ? '\\' : '/'}`));
+            },
+        });
+        return;
+    }
+    const tarballPath = pack(root, fallbackName);
+    installPackagedPackage(extractRoot, tempRoot, tarballPath, folderName);
+}
+run('npm', ['run', 'build:dist']);
+scanDirectory(resolve(packageRoot, 'dist'));
+run('npm', ['run', 'test:smoke']);
+const stageRoot = mkdtempSync(join(tmpdir(), 'treeseed-agent-release-'));
+const extractRoot = resolve(stageRoot, 'extract');
+const installRoot = resolve(stageRoot, 'install');
+try {
+    mkdirSync(extractRoot, { recursive: true });
+    const agentTarball = pack(packageRoot, 'treeseed-agent.tgz');
+    installDependencyPackage(sdkPackageRoot, extractRoot, installRoot, 'sdk', 'treeseed-sdk.tgz');
+    installDependencyPackage(corePackageRoot, extractRoot, installRoot, 'core', 'treeseed-core.tgz');
+    installPackagedPackage(extractRoot, installRoot, agentTarball, 'agent');
+    mirrorDependencies(installRoot);
+    writeFileSync(resolve(installRoot, 'package.json'), `${JSON.stringify({ name: 'treeseed-agent-smoke', private: true, type: 'module' }, null, 2)}\n`, 'utf8');
+    run(process.execPath, ['node_modules/@treeseed/agent/dist/scripts/treeseed-agents.js', '--help'], installRoot);
+    console.log('Agent packed-install bin smoke passed.');
+}
+finally {
+    rmSync(stageRoot, { recursive: true, force: true });
+}

package/dist/scripts/test-smoke.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/test-smoke.js

@@ -0,0 +1,23 @@
+import { createAgentTestRuntime } from '../agents/testing/e2e-harness.js';
+const runtime = await createAgentTestRuntime({
+    executionMode: 'stub',
+    databaseMode: 'memory',
+});
+try {
+    await runtime.seedObjectives([{ slug: 'release-smoke-objective' }]);
+    await runtime.seedQuestions([
+        {
+            slug: 'release-smoke-question',
+            relatedObjectives: ['release-smoke-objective'],
+        },
+    ]);
+    await runtime.runAgent('planner-agent');
+    const runs = await runtime.readRunLogs();
+    if (runs.length === 0) {
+        throw new Error('Agent smoke did not produce any run logs.');
+    }
+    console.log(`Agent smoke passed with ${runs.length} run log(s).`);
+}
+finally {
+    await runtime.cleanup();
+}

package/dist/scripts/treeseed-agents.d.ts

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

package/dist/scripts/treeseed-agents.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const packageRoot = fileURLToPath(new URL('..', import.meta.url));
+const cliScriptPath = fileURLToPath(new URL('../agents/cli.js', import.meta.url));
+const child = spawn(process.execPath, [cliScriptPath, ...process.argv.slice(2)], {
+    cwd: packageRoot,
+    stdio: 'inherit',
+    env: process.env,
+});
+child.on('exit', (code) => {
+    process.exit(code ?? 1);
+});

package/dist/src/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/src/agents/adapters/execution.d.ts

@@ -0,0 +1,46 @@
+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<{
+        status: "completed";
+        summary: string;
+        stdout: string;
+        stderr: string;
+    } | {
+        status: "failed";
+        summary: string;
+        stdout: string;
+        stderr: 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/src/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: any;
+        commitMessage: any;
+        worktreePath: any;
+        commitSha: any;
+        changedPaths: any;
+    }>;
+}

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

@@ -0,0 +1,11 @@
+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 function createNotificationAdapter(): StubNotificationAdapter;

package/dist/src/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/src/agents/adapters/research.d.ts

@@ -0,0 +1,14 @@
+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: never[];
+    }>;
+}
+export declare function createResearchAdapter(): StubResearchAdapter;

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

@@ -0,0 +1,36 @@
+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/src/agents/cli-tools.d.ts

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

package/dist/src/agents/cli.d.ts

@@ -0,0 +1,6 @@
+declare function parseArgs(argv: string[]): {
+    command: string;
+    args: string[];
+};
+declare function renderHelp(): string;
+declare function main(): Promise<void>;

package/dist/src/agents/content-store.d.ts

@@ -0,0 +1 @@
+export * from '@treeseed/sdk/content-store';

package/dist/src/agents/contracts/messages.d.ts

@@ -0,0 +1,88 @@
+export interface QuestionPriorityUpdatedMessage {
+    questionId: string;
+    reason: string;
+    plannerRunId: string;
+}
+export interface ObjectivePriorityUpdatedMessage {
+    objectiveId: string;
+    reason: string;
+    plannerRunId: string;
+}
+export interface ArchitectureUpdatedMessage {
+    objectiveId: string;
+    knowledgeId: string;
+    architectRunId: string;
+}
+export interface SubscriberNotifiedMessage {
+    email: string;
+    itemCount: number;
+    notifierRunId: string;
+}
+export interface ResearchStartedMessage {
+    questionId: string;
+    researcherRunId: string;
+}
+export interface ResearchCompletedMessage {
+    questionId: string;
+    knowledgeId: string | null;
+    researcherRunId: string;
+}
+export interface TaskCompleteMessage {
+    branchName: string | null;
+    changedTargets: string[];
+    engineerRunId: string;
+}
+export interface TaskWaitingMessage {
+    blockingReason: string;
+    engineerRunId: string;
+}
+export interface TaskFailedMessage {
+    failureSummary: string;
+    engineerRunId: string;
+}
+export interface TaskVerifiedMessage {
+    branchName: string | null;
+    reviewerRunId: string;
+}
+export interface ReviewFailedMessage {
+    failureSummary: string;
+    reviewerRunId: string;
+}
+export interface ReviewWaitingMessage {
+    blockingReason: string;
+    reviewerRunId: string;
+}
+export interface ReleaseStartedMessage {
+    taskRunId: string | null;
+    releaserRunId: string;
+}
+export interface ReleaseCompletedMessage {
+    releaseSummary: string;
+    releaserRunId: string;
+}
+export interface ReleaseFailedMessage {
+    failureSummary: string;
+    releaserRunId: string;
+}
+export interface AgentMessageContracts {
+    question_priority_updated: QuestionPriorityUpdatedMessage;
+    objective_priority_updated: ObjectivePriorityUpdatedMessage;
+    architecture_updated: ArchitectureUpdatedMessage;
+    subscriber_notified: SubscriberNotifiedMessage;
+    research_started: ResearchStartedMessage;
+    research_completed: ResearchCompletedMessage;
+    task_complete: TaskCompleteMessage;
+    task_waiting: TaskWaitingMessage;
+    task_failed: TaskFailedMessage;
+    task_verified: TaskVerifiedMessage;
+    review_failed: ReviewFailedMessage;
+    review_waiting: ReviewWaitingMessage;
+    release_started: ReleaseStartedMessage;
+    release_completed: ReleaseCompletedMessage;
+    release_failed: ReleaseFailedMessage;
+}
+export type AgentMessageType = keyof AgentMessageContracts;
+export type AgentMessagePayload<TType extends AgentMessageType> = AgentMessageContracts[TType];
+export declare const AGENT_MESSAGE_TYPES: readonly ["question_priority_updated", "objective_priority_updated", "architecture_updated", "subscriber_notified", "research_started", "research_completed", "task_complete", "task_waiting", "task_failed", "task_verified", "review_failed", "review_waiting", "release_started", "release_completed", "release_failed"];
+export declare function parseAgentMessagePayload<TType extends AgentMessageType>(type: TType, payloadJson: string): AgentMessagePayload<TType>;
+export declare function serializeAgentMessagePayload<TType extends AgentMessageType>(type: TType, payload: AgentMessagePayload<TType>): Record<string, unknown>;

package/dist/src/agents/contracts/run.d.ts

@@ -0,0 +1,20 @@
+export type AgentErrorCategory = 'trigger_resolution_error' | 'permission_error' | 'message_claim_error' | 'lease_error' | 'execution_error' | 'mutation_error' | 'sdk_error';
+export interface AgentRunTrace {
+    [key: string]: unknown;
+    runId: string;
+    agentSlug: string;
+    handlerKind: string;
+    triggerKind: string;
+    triggerSource: string;
+    claimedMessageId: number | null;
+    selectedItemKey: string | null;
+    branchName: string | null;
+    commitSha: string | null;
+    changedPaths: string[];
+    summary: string | null;
+    error: string | null;
+    errorCategory: AgentErrorCategory | null;
+    startedAt: string;
+    finishedAt: string | null;
+    status: string;
+}

package/dist/src/agents/d1-store.d.ts

@@ -0,0 +1 @@
+export * from '@treeseed/sdk/d1-store';

package/dist/src/agents/frontmatter.d.ts

@@ -0,0 +1 @@
+export * from '@treeseed/sdk/frontmatter';

package/dist/src/agents/git-runtime.d.ts

@@ -0,0 +1 @@
+export * from '@treeseed/sdk/git-runtime';

package/dist/src/agents/index.d.ts

@@ -0,0 +1 @@
+export { AGENT_HANDLER_REGISTRY, resolveAgentHandler } from './registry.ts';

package/dist/src/agents/kernel/agent-kernel.d.ts

@@ -0,0 +1,52 @@
+import type { AgentExecutionAdapter, AgentMutationAdapter, AgentNotificationAdapter, AgentRepositoryInspectionAdapter, AgentResearchAdapter, AgentVerificationAdapter } from '../runtime-types.ts';
+import { AgentSdk } from '../sdk.ts';
+export declare class AgentKernel {
+    private readonly sdk;
+    private readonly repoRoot;
+    private readonly execution;
+    private readonly mutations;
+    private readonly repository;
+    private readonly verification;
+    private readonly notifications;
+    private readonly research;
+    private readonly activeRuns;
+    private readonly lastRunAt;
+    constructor(sdk: AgentSdk, repoRoot: string, options?: {
+        execution?: AgentExecutionAdapter;
+        mutations?: AgentMutationAdapter;
+        repository?: AgentRepositoryInspectionAdapter;
+        verification?: AgentVerificationAdapter;
+        notifications?: AgentNotificationAdapter;
+        research?: AgentResearchAdapter;
+    });
+    doctor(): Promise<{
+        agents: {
+            slug: any;
+            handler: any;
+            enabled: any;
+            triggers: any;
+        }[];
+        diagnostics: import("../spec-types.ts").AgentSpecDiagnostic[];
+    }>;
+    private sortAgents;
+    private resolveTrigger;
+    private recordRunTrace;
+    private buildTrace;
+    private categorizeError;
+    private executeAgent;
+    runAgent(slug: string, mode?: 'auto' | 'manual'): Promise<import("../runtime-types.ts").AgentExecutionResult>;
+    runCycle(): Promise<{
+        slug: any;
+        result: import("../runtime-types.ts").AgentExecutionResult;
+    }[]>;
+    start(intervalMs?: number): Promise<void>;
+    drainMessages(): Promise<{
+        slug: any;
+        result: import("../runtime-types.ts").AgentExecutionResult;
+    }[]>;
+    releaseLeases(): any;
+    replayMessage(id: number): Promise<{
+        id: number;
+        status: string;
+    }>;
+}

package/dist/src/agents/kernel/trigger-resolver.d.ts

@@ -0,0 +1,18 @@
+import type { AgentRuntimeSpec, AgentTriggerConfig } from '@treeseed/core/types/agents';
+import type { ScopedAgentSdk } from '../sdk.ts';
+import type { AgentTriggerInvocation } from '../runtime-types.ts';
+export type TriggerDecisionKind = 'ready' | 'skip' | 'blocked_by_cooldown' | 'blocked_by_concurrency' | 'no_message_available' | 'no_follow_activity' | 'no_trigger_available';
+export interface TriggerDecision {
+    kind: TriggerDecisionKind;
+    invocation?: AgentTriggerInvocation;
+    reason?: string;
+    selectedTrigger?: AgentTriggerConfig;
+}
+export interface TriggerResolverInput {
+    agent: AgentRuntimeSpec;
+    mode?: 'auto' | 'manual';
+    isRunning: boolean;
+    lastRunAt?: number;
+    sdk: ScopedAgentSdk;
+}
+export declare function resolveTriggerDecision(input: TriggerResolverInput): Promise<TriggerDecision>;

package/dist/src/agents/model-registry.d.ts

@@ -0,0 +1 @@
+export * from '@treeseed/sdk/models';

package/dist/src/agents/registry-helper.d.ts

@@ -0,0 +1,4 @@
+import type { AgentHandlerKind } from '@treeseed/core/types/agents';
+import type { AgentHandler } from './runtime-types.ts';
+export declare function defineAgentHandlerRegistry(registry: Partial<Record<AgentHandlerKind, AgentHandler>>): Partial<Record<AgentHandlerKind, AgentHandler<unknown, unknown>>>;
+export declare function resolveAgentHandlerFromRegistry(registry: Partial<Record<AgentHandlerKind, AgentHandler>>, kind: AgentHandlerKind): AgentHandler<unknown, unknown>;

package/dist/src/agents/registry.d.ts

@@ -0,0 +1,7 @@
+import type { AgentHandlerKind } from '@treeseed/core/types/agents';
+import type { AgentHandler } from './runtime-types.ts';
+export declare function getTenantAgentHandlerModulePaths(kind: AgentHandlerKind, tenantRoot?: string): string[];
+export declare function loadTenantAgentHandlerRegistry(tenantRoot?: string): Promise<Record<string, AgentHandler>>;
+export declare const AGENT_HANDLER_REGISTRY: Record<string, AgentHandler<unknown, unknown>>;
+export declare function listRegisteredAgentHandlers(): string[];
+export declare function resolveAgentHandler(kind: AgentHandlerKind): AgentHandler<unknown, unknown>;