@clinebot/core 0.0.18 → 0.0.21

package/src/runtime/index.ts

@@ -1,37 +0,0 @@
-export {
-	type AvailableRuntimeCommand,
-	listAvailableRuntimeCommandsFromWatcher,
-	resolveRuntimeSlashCommandFromWatcher,
-} from "./commands";
-export {
-	formatRulesForSystemPrompt,
-	isRuleEnabled,
-	listEnabledRulesFromWatcher,
-	loadRulesForSystemPromptFromWatcher,
-} from "./rules";
-export { createTeamName, DefaultRuntimeBuilder } from "./runtime-builder";
-export {
-	type SandboxCallOptions,
-	SubprocessSandbox,
-	type SubprocessSandboxOptions,
-} from "./sandbox/subprocess-sandbox";
-export type {
-	BuiltRuntime,
-	RuntimeBuilder,
-	RuntimeBuilderInput,
-	SessionRuntime,
-} from "./session-runtime";
-export {
-	type AvailableSkill,
-	listAvailableSkillsFromWatcher,
-	resolveSkillsSlashCommandFromWatcher,
-} from "./skills";
-export {
-	type DesktopToolApprovalOptions,
-	requestDesktopToolApproval,
-} from "./tool-approval";
-export {
-	type AvailableWorkflow,
-	listAvailableWorkflowsFromWatcher,
-	resolveWorkflowSlashCommandFromWatcher,
-} from "./workflows";

package/src/runtime/rules.ts

@@ -1,34 +0,0 @@
-import type { RuleConfig, UserInstructionConfigWatcher } from "../agents";
-
-export function isRuleEnabled(rule: RuleConfig): boolean {
-	return rule.disabled !== true;
-}
-
-export function formatRulesForSystemPrompt(
-	rules: ReadonlyArray<RuleConfig>,
-): string {
-	if (rules.length === 0) {
-		return "";
-	}
-
-	const renderedRules = rules
-		.map((rule) => `## ${rule.name}\n${rule.instructions}`)
-		.join("\n\n");
-	return `\n\n# Rules\n${renderedRules}`;
-}
-
-export function listEnabledRulesFromWatcher(
-	watcher: UserInstructionConfigWatcher,
-): RuleConfig[] {
-	const snapshot = watcher.getSnapshot("rule");
-	return [...snapshot.values()]
-		.map((record) => record.item as RuleConfig)
-		.filter(isRuleEnabled)
-		.sort((a, b) => a.name.localeCompare(b.name));
-}
-
-export function loadRulesForSystemPromptFromWatcher(
-	watcher: UserInstructionConfigWatcher,
-): string {
-	return formatRulesForSystemPrompt(listEnabledRulesFromWatcher(watcher));
-}

package/src/runtime/runtime-builder.team-persistence.test.ts

@@ -1,202 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-const createBuiltinToolsMock = vi.fn(() => []);
-const bootstrapAgentTeamsMock = vi.fn(() => ({
-	tools: [],
-	restoredFromPersistence: true,
-	restoredTeammates: ["restored-1"],
-}));
-
-let runtimeInstance: MockAgentTeamsRuntime | undefined;
-class MockAgentTeamsRuntime {
-	private readonly onTeamEvent?: (event: any) => void;
-
-	constructor(options: { onTeamEvent?: (event: any) => void }) {
-		this.onTeamEvent = options.onTeamEvent;
-		runtimeInstance = this;
-	}
-
-	emit(event: any): void {
-		this.onTeamEvent?.(event);
-	}
-
-	hydrateState = vi.fn();
-	exportState = vi.fn(() => ({
-		members: [],
-		tasks: [],
-		mailbox: [],
-		missionLog: [],
-		runs: [],
-		outcomes: [],
-		outcomeFragments: [],
-	}));
-	markStaleRunsInterrupted = vi.fn();
-	getTeammateIds = vi.fn(() => []);
-	shutdownTeammate = vi.fn();
-}
-
-vi.mock("@clinebot/agents", () => ({
-	AgentTeamsRuntime: MockAgentTeamsRuntime,
-	bootstrapAgentTeams: bootstrapAgentTeamsMock,
-}));
-
-vi.mock("../default-tools", () => ({
-	ALL_DEFAULT_TOOL_NAMES: [],
-	createBuiltinTools: createBuiltinToolsMock,
-	ToolPresets: {
-		development: {},
-		readonly: {},
-	},
-}));
-
-let teamStoreInstance: MockTeamStore | undefined;
-class MockTeamStore {
-	constructor() {
-		teamStoreInstance = this;
-	}
-
-	loadRuntime = vi.fn(() => ({
-		state: {
-			teamId: "team_1",
-			teamName: "test",
-			members: [],
-			tasks: [],
-			mailbox: [],
-			missionLog: [],
-			runs: [],
-			outcomes: [],
-			outcomeFragments: [],
-		},
-		teammates: [
-			{
-				agentId: "restored-1",
-				rolePrompt: "Persisted teammate",
-				modelId: "claude-sonnet-4-5-20250929",
-				maxIterations: 4,
-			},
-		],
-		interruptedRunIds: ["run_00001"],
-	}));
-	handleTeamEvent = vi.fn();
-	persistRuntime = vi.fn();
-}
-
-vi.mock("../storage/team-store", () => ({
-	createLocalTeamStore: () => new MockTeamStore(),
-}));
-
-describe("DefaultRuntimeBuilder team persistence boundary", () => {
-	it("persists teammate specs and runtime state from team events", async () => {
-		const { DefaultRuntimeBuilder } = await import("./runtime-builder");
-		const onTeamRestored = vi.fn();
-
-		new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				headers: {
-					Authorization: "Bearer team-token",
-				},
-				systemPrompt: "test",
-				cwd: process.cwd(),
-				enableTools: false,
-				enableSpawnAgent: false,
-				enableAgentTeams: true,
-			},
-			onTeamRestored,
-		});
-
-		expect(bootstrapAgentTeamsMock).toHaveBeenCalledWith(
-			expect.objectContaining({
-				restoredFromPersistence: true,
-				restoredTeammates: [expect.objectContaining({ agentId: "restored-1" })],
-				teammateRuntime: expect.objectContaining({
-					headers: {
-						Authorization: "Bearer team-token",
-					},
-				}),
-			}),
-		);
-		expect(onTeamRestored).toHaveBeenCalledTimes(1);
-		expect(runtimeInstance).toBeDefined();
-		expect(teamStoreInstance).toBeDefined();
-		if (!runtimeInstance || !teamStoreInstance) {
-			throw new Error("Expected mocked runtime and team store instances");
-		}
-
-		expect(runtimeInstance.markStaleRunsInterrupted).toHaveBeenCalledWith(
-			"runtime_recovered",
-		);
-
-		runtimeInstance.emit({
-			type: "teammate_spawned",
-			agentId: "python-poet",
-			teammate: {
-				rolePrompt: "Write concise Python-focused haiku",
-				modelId: "claude-sonnet-4-5-20250929",
-				maxIterations: 7,
-			},
-		});
-		expect(teamStoreInstance.handleTeamEvent).toHaveBeenCalledWith(
-			expect.any(String),
-			expect.objectContaining({
-				type: "teammate_spawned",
-				agentId: "python-poet",
-			}),
-		);
-		expect(teamStoreInstance.persistRuntime).toHaveBeenCalled();
-
-		runtimeInstance.emit({
-			type: "teammate_shutdown",
-			agentId: "python-poet",
-		});
-		expect(teamStoreInstance.handleTeamEvent).toHaveBeenCalledWith(
-			expect.any(String),
-			expect.objectContaining({
-				type: "teammate_shutdown",
-				agentId: "python-poet",
-			}),
-		);
-	});
-
-	it("forwards cline workspace metadata to teammate runtime bootstrap config", async () => {
-		const { DefaultRuntimeBuilder } = await import("./runtime-builder");
-		bootstrapAgentTeamsMock.mockClear();
-
-		new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "cline",
-				modelId: "anthropic/claude-sonnet-4.6",
-				apiKey: "key",
-				systemPrompt: `Base instructions.
-
-# Workspace Configuration
-{
-  "workspaces": {
-    "/repo/demo": {
-      "hint": "demo",
-      "latestGitBranchName": "main"
-    }
-  }
-}`,
-				cwd: "/repo/demo",
-				enableTools: false,
-				enableSpawnAgent: false,
-				enableAgentTeams: true,
-			},
-		});
-
-		expect(bootstrapAgentTeamsMock).toHaveBeenCalledWith(
-			expect.objectContaining({
-				teammateRuntime: expect.objectContaining({
-					providerId: "cline",
-					cwd: "/repo/demo",
-					clineWorkspaceMetadata: expect.stringContaining(
-						"# Workspace Configuration",
-					),
-				}),
-			}),
-		);
-	});
-});

package/src/runtime/runtime-builder.test.ts

@@ -1,371 +0,0 @@
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { Tool } from "@clinebot/agents";
-import { describe, expect, it } from "vitest";
-import { TelemetryService } from "../telemetry/TelemetryService";
-import { DefaultRuntimeBuilder } from "./runtime-builder";
-
-function makeSpawnTool(): Tool {
-	return {
-		name: "spawn_agent",
-		description: "Spawn a subagent",
-		inputSchema: { type: "object", properties: {}, required: [] },
-		execute: async () => ({ ok: true }),
-	};
-}
-
-describe("DefaultRuntimeBuilder", () => {
-	it("includes builtin tools when enabled", () => {
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd: process.cwd(),
-				enableTools: true,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-			},
-		});
-
-		const names = runtime.tools.map((tool) => tool.name);
-		expect(names.length).toBeGreaterThan(0);
-		expect(names).not.toContain("spawn_agent");
-	});
-
-	it("forwards runtime logger for downstream agent creation", () => {
-		const logger = {
-			info: () => {},
-		};
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd: process.cwd(),
-				enableTools: false,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-				logger,
-			},
-		});
-
-		expect(runtime.logger).toBe(logger);
-	});
-
-	it("forwards telemetry for downstream runtime consumers", () => {
-		const telemetry = new TelemetryService();
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd: process.cwd(),
-				enableTools: false,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-				telemetry,
-			},
-		});
-
-		expect(runtime.telemetry).toBe(telemetry);
-	});
-
-	it("uses readonly preset in plan mode", () => {
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd: process.cwd(),
-				mode: "plan",
-				enableTools: true,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-			},
-		});
-
-		const names = runtime.tools.map((tool) => tool.name);
-		expect(names).not.toContain("editor");
-	});
-
-	it("uses apply_patch instead of editor for codex/gpt model IDs in act mode", () => {
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "openai",
-				modelId: "openai/gpt-5.4",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd: process.cwd(),
-				mode: "act",
-				enableTools: true,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-			},
-		});
-
-		const names = runtime.tools.map((tool) => tool.name);
-		expect(names).toContain("apply_patch");
-		expect(names).not.toContain("editor");
-	});
-
-	it("keeps editor for non-codex/non-gpt model IDs in act mode", () => {
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd: process.cwd(),
-				mode: "act",
-				enableTools: true,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-			},
-		});
-
-		const names = runtime.tools.map((tool) => tool.name);
-		expect(names).toContain("editor");
-		expect(names).not.toContain("apply_patch");
-	});
-
-	it("applies custom tool routing rules from session config", () => {
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd: process.cwd(),
-				mode: "act",
-				enableTools: true,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-				toolRoutingRules: [
-					{
-						mode: "act",
-						providerIdIncludes: ["anthropic"],
-						modelIdIncludes: ["claude"],
-						enableTools: ["apply_patch"],
-						disableTools: ["editor"],
-					},
-				],
-			},
-		});
-
-		const names = runtime.tools.map((tool) => tool.name);
-		expect(names).toContain("apply_patch");
-		expect(names).not.toContain("editor");
-	});
-
-	it("omits builtin tools when disabled", () => {
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd: process.cwd(),
-				enableTools: false,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-			},
-		});
-
-		expect(runtime.tools).toEqual([]);
-	});
-
-	it("adds spawn tool when enabled", () => {
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd: process.cwd(),
-				enableTools: false,
-				enableSpawnAgent: true,
-				enableAgentTeams: false,
-			},
-			createSpawnTool: makeSpawnTool,
-		});
-
-		expect(runtime.tools.map((tool) => tool.name)).toContain("spawn_agent");
-	});
-
-	it("provides a shutdown helper", () => {
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd: process.cwd(),
-				enableTools: false,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-			},
-		});
-
-		expect(() => runtime.shutdown("test")).not.toThrow();
-	});
-
-	it("includes skills tool when workspace skills are available", () => {
-		const cwd = mkdtempSync(join(tmpdir(), "runtime-builder-skills-"));
-		const skillDir = join(cwd, ".cline", "skills", "commit");
-		mkdirSync(skillDir, { recursive: true });
-		writeFileSync(
-			join(skillDir, "SKILL.md"),
-			`---
-name: commit
-description: Create commit message
----
-Use conventional commits.`,
-			"utf8",
-		);
-
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd,
-				enableTools: true,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-			},
-		});
-
-		expect(runtime.tools.map((tool) => tool.name)).toContain("skills");
-		runtime.shutdown("test");
-	});
-
-	it("marks configured but disabled skills in executor metadata", async () => {
-		const cwd = mkdtempSync(join(tmpdir(), "runtime-builder-skills-disabled-"));
-		const enabledDir = join(cwd, ".cline", "skills", "commit");
-		const disabledDir = join(cwd, ".cline", "skills", "review");
-		mkdirSync(enabledDir, { recursive: true });
-		mkdirSync(disabledDir, { recursive: true });
-		writeFileSync(
-			join(enabledDir, "SKILL.md"),
-			`---
-name: commit
----
-Enabled skill.`,
-			"utf8",
-		);
-		writeFileSync(
-			join(disabledDir, "SKILL.md"),
-			`---
-name: review
-disabled: true
----
-Disabled skill.`,
-			"utf8",
-		);
-
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd,
-				enableTools: true,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-			},
-		});
-
-		const skillsTool = runtime.tools.find((tool) => tool.name === "skills");
-		expect(skillsTool).toBeDefined();
-		if (!skillsTool) {
-			throw new Error("Expected skills tool.");
-		}
-
-		const disabledResult = await skillsTool.execute(
-			{ skill: "review" },
-			{
-				agentId: "agent-1",
-				conversationId: "conv-1",
-				iteration: 1,
-			},
-		);
-		expect(disabledResult).toContain("configured but disabled");
-
-		runtime.shutdown("test");
-	});
-
-	it("scopes skills tool to session-configured skills", async () => {
-		const cwd = mkdtempSync(join(tmpdir(), "runtime-builder-skills-scoped-"));
-		const commitDir = join(cwd, ".cline", "skills", "commit");
-		const reviewDir = join(cwd, ".cline", "skills", "review");
-		mkdirSync(commitDir, { recursive: true });
-		mkdirSync(reviewDir, { recursive: true });
-		writeFileSync(
-			join(commitDir, "SKILL.md"),
-			`---
-name: commit
----
-Commit skill.`,
-			"utf8",
-		);
-		writeFileSync(
-			join(reviewDir, "SKILL.md"),
-			`---
-name: review
----
-Review skill.`,
-			"utf8",
-		);
-
-		const runtime = new DefaultRuntimeBuilder().build({
-			config: {
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4-6",
-				apiKey: "key",
-				systemPrompt: "test",
-				cwd,
-				enableTools: true,
-				enableSpawnAgent: false,
-				enableAgentTeams: false,
-				skills: ["commit"],
-			},
-		});
-
-		const skillsTool = runtime.tools.find((tool) => tool.name === "skills");
-		expect(skillsTool).toBeDefined();
-		if (!skillsTool) {
-			throw new Error("Expected skills tool.");
-		}
-
-		const known = await skillsTool.execute(
-			{ skill: "commit" },
-			{
-				agentId: "agent-1",
-				conversationId: "conv-1",
-				iteration: 1,
-			},
-		);
-		expect(known).toContain("<command-name>commit</command-name>");
-
-		const blocked = await skillsTool.execute(
-			{ skill: "review" },
-			{
-				agentId: "agent-1",
-				conversationId: "conv-1",
-				iteration: 1,
-			},
-		);
-		expect(blocked).toContain('Skill "review" not found.');
-		expect(blocked).toContain("Available skills: commit");
-
-		runtime.shutdown("test");
-	});
-});