@clinebot/core 0.0.35 → 0.0.36

package/src/extensions/config/runtime-commands.test.ts

@@ -1,115 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-	listAvailableRuntimeCommandsFromWatcher,
-	resolveRuntimeSlashCommandFromWatcher,
-} from "./runtime-commands";
-import { createUserInstructionConfigWatcher } from "./user-instruction-config-loader";
-
-describe("runtime command registry", () => {
-	const tempRoots: string[] = [];
-
-	afterEach(async () => {
-		await Promise.all(
-			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
-		);
-		tempRoots.length = 0;
-	});
-
-	it("lists workflow and skill commands together", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-commands-"));
-		tempRoots.push(tempRoot);
-		const skillDir = join(tempRoot, "skills", "debug");
-		const workflowsDir = join(tempRoot, "workflows");
-		await mkdir(skillDir, { recursive: true });
-		await mkdir(workflowsDir, { recursive: true });
-		await writeFile(join(skillDir, "SKILL.md"), "Use the debugging skill.");
-		await writeFile(
-			join(workflowsDir, "release.md"),
-			`---
-name: release
----
-Run the release workflow.`,
-		);
-
-		const watcher = createUserInstructionConfigWatcher({
-			skills: { directories: [join(tempRoot, "skills")] },
-			rules: { directories: [] },
-			workflows: { directories: [workflowsDir] },
-		});
-
-		try {
-			await watcher.start();
-			expect(listAvailableRuntimeCommandsFromWatcher(watcher)).toEqual([
-				{
-					id: "debug",
-					name: "debug",
-					instructions: "Use the debugging skill.",
-					kind: "skill",
-				},
-				{
-					id: "release",
-					name: "release",
-					instructions: "Run the release workflow.",
-					kind: "workflow",
-				},
-			]);
-		} finally {
-			watcher.stop();
-		}
-	});
-
-	it("expands slash commands with workflow precedence and ignores disabled entries", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-commands-"));
-		tempRoots.push(tempRoot);
-		const skillDir = join(tempRoot, "skills", "ship");
-		const workflowsDir = join(tempRoot, "workflows");
-		await mkdir(skillDir, { recursive: true });
-		await mkdir(workflowsDir, { recursive: true });
-		await writeFile(join(skillDir, "SKILL.md"), "Use the ship skill.");
-		await writeFile(
-			join(workflowsDir, "ship.md"),
-			`---
-name: ship
----
-Run the ship workflow.`,
-		);
-		await writeFile(
-			join(workflowsDir, "disabled.md"),
-			`---
-name: disabled
-disabled: true
----
-Do not run this workflow.`,
-		);
-
-		const watcher = createUserInstructionConfigWatcher({
-			skills: { directories: [join(tempRoot, "skills")] },
-			rules: { directories: [] },
-			workflows: { directories: [workflowsDir] },
-		});
-
-		try {
-			await watcher.start();
-			expect(resolveRuntimeSlashCommandFromWatcher("/ship", watcher)).toBe(
-				"Run the ship workflow.",
-			);
-			expect(resolveRuntimeSlashCommandFromWatcher("/ship now", watcher)).toBe(
-				"Run the ship workflow. now",
-			);
-			expect(resolveRuntimeSlashCommandFromWatcher("/disabled", watcher)).toBe(
-				"/disabled",
-			);
-			expect(resolveRuntimeSlashCommandFromWatcher("/missing", watcher)).toBe(
-				"/missing",
-			);
-			expect(
-				resolveRuntimeSlashCommandFromWatcher("please run /ship", watcher),
-			).toBe("please run /ship");
-		} finally {
-			watcher.stop();
-		}
-	});
-});

package/src/extensions/config/unified-config-file-watcher.test.ts

@@ -1,196 +0,0 @@
-import { mkdir, mkdtemp, rm, unlink, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { basename, join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-	type AgentYamlConfig,
-	parseAgentConfigFromYaml,
-} from "./agent-config-loader";
-import {
-	UnifiedConfigFileWatcher,
-	type UnifiedConfigWatcherEvent,
-} from "./unified-config-file-watcher";
-
-const WAIT_TIMEOUT_MS = 8_000;
-const WAIT_INTERVAL_MS = 25;
-
-async function waitForEvent<TType extends string, TItem>(
-	events: Array<UnifiedConfigWatcherEvent<TType, TItem>>,
-	predicate: (event: UnifiedConfigWatcherEvent<TType, TItem>) => boolean,
-	timeoutMs = WAIT_TIMEOUT_MS,
-): Promise<UnifiedConfigWatcherEvent<TType, TItem>> {
-	const startedAt = Date.now();
-	while (Date.now() - startedAt < timeoutMs) {
-		const match = events.find(predicate);
-		if (match) {
-			return match;
-		}
-		await new Promise((resolve) => setTimeout(resolve, WAIT_INTERVAL_MS));
-	}
-	throw new Error("Timed out waiting for watcher event.");
-}
-
-describe("UnifiedConfigFileWatcher", () => {
-	const tempRoots: string[] = [];
-
-	afterEach(async () => {
-		await Promise.all(
-			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
-		);
-		tempRoots.length = 0;
-	});
-
-	it("emits upsert and remove events with config type for agent configs", async () => {
-		const tempRoot = await mkdtemp(
-			join(tmpdir(), "core-unified-config-watcher-"),
-		);
-		tempRoots.push(tempRoot);
-		const agentsDir = join(tempRoot, "agents");
-		await mkdir(agentsDir, { recursive: true });
-		const agentFilePath = join(agentsDir, "reviewer.yaml");
-		await writeFile(
-			agentFilePath,
-			`---
-name: Reviewer
-description: Reviews patches
-tools: read_files
----
-Review code carefully.`,
-		);
-
-		const watcher = new UnifiedConfigFileWatcher([
-			{
-				type: "agent" as const,
-				directories: [agentsDir],
-				includeFile: (fileName) => /\.(yaml|yml)$/i.test(fileName),
-				parseFile: (context) => parseAgentConfigFromYaml(context.content),
-				resolveId: (config) => config.name.toLowerCase(),
-			},
-		]);
-
-		const events: Array<
-			UnifiedConfigWatcherEvent<
-				"agent",
-				ReturnType<typeof parseAgentConfigFromYaml>
-			>
-		> = [];
-		const unsubscribe = watcher.subscribe((event) => events.push(event));
-
-		try {
-			await watcher.start();
-			await waitForEvent(
-				events,
-				(event) => event.kind === "upsert" && event.record.id === "reviewer",
-			);
-
-			events.length = 0;
-			await writeFile(
-				agentFilePath,
-				`---
-name: Reviewer
-description: Reviews patches
----
-Review code with strictness.`,
-			);
-			await watcher.refreshType("agent");
-			await waitForEvent(
-				events,
-				(event) => event.kind === "upsert" && event.record.type === "agent",
-			);
-
-			events.length = 0;
-			await unlink(agentFilePath);
-			await watcher.refreshType("agent");
-			await waitForEvent(
-				events,
-				(event) => event.kind === "remove" && event.type === "agent",
-			);
-		} finally {
-			unsubscribe();
-			watcher.stop();
-		}
-	}, 15_000);
-
-	it("supports one watcher instance for multiple config types", async () => {
-		const tempRoot = await mkdtemp(
-			join(tmpdir(), "core-unified-config-watcher-"),
-		);
-		tempRoots.push(tempRoot);
-		const agentsDir = join(tempRoot, "agents");
-		const skillsDir = join(tempRoot, "skills");
-		await mkdir(agentsDir, { recursive: true });
-		await mkdir(skillsDir, { recursive: true });
-
-		await writeFile(
-			join(agentsDir, "researcher.yaml"),
-			`---
-name: Researcher
-description: Finds context
----
-Investigate related code paths.`,
-		);
-		await writeFile(
-			join(skillsDir, "SKILL.md"),
-			`---
-name: incident-response
-description: Handle incidents
----
-Escalation playbook`,
-		);
-
-		const watcher = new UnifiedConfigFileWatcher<
-			"agent" | "skill",
-			AgentYamlConfig | { path: string }
-		>([
-			{
-				type: "agent" as const,
-				directories: [agentsDir],
-				includeFile: (fileName) => /\.(yaml|yml)$/i.test(fileName),
-				parseFile: (context) =>
-					parseAgentConfigFromYaml(context.content) as
-						| AgentYamlConfig
-						| { path: string },
-				resolveId: (config) =>
-					"name" in config ? config.name.toLowerCase() : "invalid-agent-config",
-			},
-			{
-				type: "skill" as const,
-				directories: [skillsDir],
-				includeFile: (fileName) => fileName === "SKILL.md",
-				parseFile: (context) => ({ path: context.filePath }),
-				resolveId: (_parsed, context) => basename(context.directoryPath),
-			},
-		]);
-
-		const events: Array<
-			UnifiedConfigWatcherEvent<
-				"agent" | "skill",
-				AgentYamlConfig | { path: string }
-			>
-		> = [];
-		const unsubscribe = watcher.subscribe((event) => events.push(event));
-
-		try {
-			await watcher.start();
-			await waitForEvent(
-				events,
-				(event) =>
-					event.kind === "upsert" &&
-					(event.record.type === "agent" || event.record.type === "skill"),
-			);
-			expect(
-				events.some(
-					(event) => event.kind === "upsert" && event.record.type === "agent",
-				),
-			).toBe(true);
-			expect(
-				events.some(
-					(event) => event.kind === "upsert" && event.record.type === "skill",
-				),
-			).toBe(true);
-		} finally {
-			unsubscribe();
-			watcher.stop();
-		}
-	});
-});

package/src/extensions/config/user-instruction-config-loader.test.ts

@@ -1,246 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-	createRulesConfigDefinition,
-	createSkillsConfigDefinition,
-	createUserInstructionConfigWatcher,
-	createWorkflowsConfigDefinition,
-	parseRuleConfigFromMarkdown,
-	parseSkillConfigFromMarkdown,
-	parseWorkflowConfigFromMarkdown,
-	resolveRulesConfigSearchPaths,
-	resolveSkillsConfigSearchPaths,
-	resolveWorkflowsConfigSearchPaths,
-	type UserInstructionConfigWatcherEvent,
-} from "./user-instruction-config-loader";
-
-const WAIT_TIMEOUT_MS = 4_000;
-const WAIT_INTERVAL_MS = 25;
-
-async function waitForEvent(
-	events: Array<UserInstructionConfigWatcherEvent>,
-	predicate: (event: UserInstructionConfigWatcherEvent) => boolean,
-	timeoutMs = WAIT_TIMEOUT_MS,
-): Promise<UserInstructionConfigWatcherEvent> {
-	const startedAt = Date.now();
-	while (Date.now() - startedAt < timeoutMs) {
-		const match = events.find(predicate);
-		if (match) {
-			return match;
-		}
-		await new Promise((resolve) => setTimeout(resolve, WAIT_INTERVAL_MS));
-	}
-	throw new Error("Timed out waiting for watcher event.");
-}
-
-describe("user instruction config loader", () => {
-	const tempRoots: string[] = [];
-
-	afterEach(async () => {
-		await Promise.all(
-			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
-		);
-		tempRoots.length = 0;
-	});
-
-	it("resolves legacy-compatible default search paths", () => {
-		const workspacePath = "/repo/demo";
-		expect(resolveSkillsConfigSearchPaths(workspacePath)).toEqual(
-			expect.arrayContaining([
-				join(workspacePath, ".clinerules", "skills"),
-				join(workspacePath, ".cline", "skills"),
-				join(workspacePath, ".agents", "skills"),
-			]),
-		);
-		expect(resolveRulesConfigSearchPaths(workspacePath)).toEqual(
-			expect.arrayContaining([
-				join(workspacePath, "AGENTS.md"),
-				join(workspacePath, ".clinerules"),
-				join(workspacePath, ".cline", "rules"),
-			]),
-		);
-		expect(resolveWorkflowsConfigSearchPaths(workspacePath)).toEqual(
-			expect.arrayContaining([join(workspacePath, ".clinerules", "workflows")]),
-		);
-	});
-
-	it("discovers managed plugin instruction roots from workspace .cline manifests", () => {
-		const workspacePath = "/repo/demo";
-		expect(
-			createSkillsConfigDefinition({ workspacePath }).directories,
-		).toContain(join(workspacePath, ".cline"));
-		expect(
-			createRulesConfigDefinition({ workspacePath }).directories,
-		).toContain(join(workspacePath, ".cline"));
-		expect(
-			createWorkflowsConfigDefinition({ workspacePath }).directories,
-		).toContain(join(workspacePath, ".cline"));
-	});
-
-	it("parses markdown frontmatter for skill, rule, and workflow configs", () => {
-		const skill = parseSkillConfigFromMarkdown(
-			`---
-name: debugging
-description: Use structured debugging
-disabled: true
----
-Follow the debugging checklist.`,
-			"fallback",
-		);
-		expect(skill.name).toBe("debugging");
-		expect(skill.description).toBe("Use structured debugging");
-		expect(skill.disabled).toBe(true);
-		expect(skill.instructions).toBe("Follow the debugging checklist.");
-
-		const rule = parseRuleConfigFromMarkdown(
-			`---
-name: rule-a
-disabled: true
----
-Always run tests before merge.`,
-			"rule-a",
-		);
-		expect(rule.name).toBe("rule-a");
-		expect(rule.disabled).toBe(true);
-
-		const workflow = parseWorkflowConfigFromMarkdown(
-			`---
-name: release
-disabled: true
----
-Document rollout and rollback steps.`,
-			"release",
-		);
-		expect(workflow.name).toBe("release");
-		expect(workflow.disabled).toBe(true);
-	});
-
-	it("emits typed events for skills, rules, and workflows in one watcher", async () => {
-		const tempRoot = await mkdtemp(
-			join(tmpdir(), "core-user-instructions-loader-"),
-		);
-		tempRoots.push(tempRoot);
-		const skillsDir = join(tempRoot, "skills");
-		const rulesDir = join(tempRoot, "rules");
-		const workflowsDir = join(tempRoot, "workflows");
-		await mkdir(join(skillsDir, "incident-response"), { recursive: true });
-		await mkdir(rulesDir, { recursive: true });
-		await mkdir(workflowsDir, { recursive: true });
-
-		await writeFile(
-			join(skillsDir, "incident-response", "SKILL.md"),
-			`---
-name: incident-response
-description: Handle incidents fast
----
-Escalation runbook`,
-		);
-		await writeFile(
-			join(rulesDir, "default.md"),
-			"Keep changes minimal and tested.",
-		);
-		await writeFile(
-			join(workflowsDir, "release.md"),
-			"Ship with release checklist.",
-		);
-
-		const watcher = createUserInstructionConfigWatcher({
-			skills: { directories: [skillsDir] },
-			rules: { directories: [rulesDir] },
-			workflows: { directories: [workflowsDir] },
-		});
-
-		const events: Array<UserInstructionConfigWatcherEvent> = [];
-		const unsubscribe = watcher.subscribe((event) => events.push(event));
-
-		try {
-			await watcher.start();
-			await waitForEvent(
-				events,
-				(event) => event.kind === "upsert" && event.record.type === "skill",
-			);
-			await waitForEvent(
-				events,
-				(event) => event.kind === "upsert" && event.record.type === "rule",
-			);
-			await waitForEvent(
-				events,
-				(event) => event.kind === "upsert" && event.record.type === "workflow",
-			);
-		} finally {
-			unsubscribe();
-			watcher.stop();
-		}
-	});
-
-	it("loads enterprise-style managed rules, workflows, and skills through the default workspace watcher", async () => {
-		const tempRoot = await mkdtemp(
-			join(tmpdir(), "core-user-instructions-managed-"),
-		);
-		tempRoots.push(tempRoot);
-
-		const pluginRoot = join(tempRoot, ".cline", "enterprise");
-		await mkdir(join(pluginRoot, "workflows"), { recursive: true });
-		await mkdir(join(pluginRoot, "skills", "security-review"), {
-			recursive: true,
-		});
-		await writeFile(
-			join(pluginRoot, "managed.json"),
-			JSON.stringify({ source: "enterprise", version: "1", files: [] }),
-		);
-		await writeFile(
-			join(pluginRoot, "rules.md"),
-			`---
-name: enterprise-policy
----
-Follow enterprise policy.`,
-		);
-		await writeFile(
-			join(pluginRoot, "workflows", "triage.md"),
-			`---
-name: triage
----
-Follow the triage workflow.`,
-		);
-		await writeFile(
-			join(pluginRoot, "skills", "security-review", "SKILL.md"),
-			`---
-name: security-review
----
-Use the security review checklist.`,
-		);
-
-		const watcher = createUserInstructionConfigWatcher({
-			skills: { workspacePath: tempRoot },
-			rules: { workspacePath: tempRoot },
-			workflows: { workspacePath: tempRoot },
-		});
-
-		try {
-			await watcher.start();
-			const rules = watcher.getSnapshot("rule");
-			const workflows = watcher.getSnapshot("workflow");
-			const skills = watcher.getSnapshot("skill");
-
-			expect(
-				[...rules.values()].some((rule) =>
-					rule.item.instructions.includes("enterprise policy"),
-				),
-			).toBe(true);
-			expect(
-				[...workflows.values()].some((workflow) =>
-					workflow.item.instructions.includes("triage workflow"),
-				),
-			).toBe(true);
-			expect(
-				[...skills.values()].some((skill) =>
-					skill.item.instructions.includes("security review checklist"),
-				),
-			).toBe(true);
-		} finally {
-			watcher.stop();
-		}
-	});
-});