@clinebot/core 0.0.37 → 0.0.38

package/src/extensions/config/agent-config-loader.ts

@@ -1,114 +0,0 @@
-import {
-	AGENT_CONFIG_DIRECTORY_NAME,
-	resolveAgentConfigSearchPaths as resolveAgentConfigSearchPathsFromShared,
-	resolveAgentsConfigDirPath as resolveAgentsConfigDirPathFromShared,
-} from "@clinebot/shared/storage";
-import {
-	type AgentYamlConfig,
-	isAgentConfigYamlFile,
-	normalizeAgentConfigName,
-	parseAgentConfigFromYaml,
-} from "./agent-config-parser";
-import {
-	type UnifiedConfigDefinition,
-	UnifiedConfigFileWatcher,
-	type UnifiedConfigWatcherEvent,
-} from "./unified-config-file-watcher";
-
-export type {
-	AgentYamlConfig,
-	BuildAgentConfigOverridesOptions,
-	ParseYamlFrontmatterResult,
-	PartialAgentConfigOverrides,
-} from "./agent-config-parser";
-export {
-	parseAgentConfigFromYaml,
-	parsePartialAgentConfigFromYaml,
-	resolveAgentTools,
-	toPartialAgentConfig,
-} from "./agent-config-parser";
-
-export type AgentConfigWatcher = UnifiedConfigFileWatcher<
-	"agent",
-	AgentYamlConfig
->;
-export type AgentConfigWatcherEvent = UnifiedConfigWatcherEvent<
-	"agent",
-	AgentYamlConfig
->;
-
-export { AGENT_CONFIG_DIRECTORY_NAME };
-
-export function resolveAgentsConfigDirPath(): string {
-	return resolveAgentsConfigDirPathFromShared();
-}
-
-export function resolveAgentConfigSearchPaths(
-	workspacePath?: string,
-): string[] {
-	return resolveAgentConfigSearchPathsFromShared(workspacePath);
-}
-
-export interface CreateAgentConfigWatcherOptions {
-	workspacePath?: string;
-	directoryPathOrPaths?: string | ReadonlyArray<string>;
-	debounceMs?: number;
-	emitParseErrors?: boolean;
-}
-
-function toDirectoryPaths(
-	directoryPathOrPaths?: string | ReadonlyArray<string>,
-	workspacePath?: string,
-): string[] {
-	if (Array.isArray(directoryPathOrPaths)) {
-		return [...directoryPathOrPaths];
-	}
-	if (typeof directoryPathOrPaths === "string") {
-		return [directoryPathOrPaths];
-	}
-	return resolveAgentConfigSearchPaths(workspacePath);
-}
-
-export function createAgentConfigDefinition(
-	directoryPathOrPaths?: string | ReadonlyArray<string>,
-	workspacePath?: string,
-): UnifiedConfigDefinition<"agent", AgentYamlConfig> {
-	return {
-		type: "agent",
-		directories: toDirectoryPaths(directoryPathOrPaths, workspacePath),
-		includeFile: (fileName) => isAgentConfigYamlFile(fileName),
-		parseFile: (context) => parseAgentConfigFromYaml(context.content),
-		resolveId: (config) => normalizeAgentConfigName(config.name),
-	};
-}
-
-export function createAgentConfigWatcher(
-	options?: CreateAgentConfigWatcherOptions,
-): AgentConfigWatcher {
-	return new UnifiedConfigFileWatcher(
-		[
-			createAgentConfigDefinition(
-				options?.directoryPathOrPaths,
-				options?.workspacePath,
-			),
-		],
-		{
-			debounceMs: options?.debounceMs,
-			emitParseErrors: options?.emitParseErrors,
-		},
-	);
-}
-
-export async function readAgentConfigsFromDisk(
-	directoryPathOrPaths?: string | ReadonlyArray<string>,
-	workspacePath?: string,
-): Promise<Map<string, AgentYamlConfig>> {
-	const watcher = new UnifiedConfigFileWatcher([
-		createAgentConfigDefinition(directoryPathOrPaths, workspacePath),
-	]);
-	await watcher.refreshAll();
-	const snapshot = watcher.getSnapshot("agent");
-	return new Map(
-		[...snapshot.entries()].map(([id, record]) => [id, record.item]),
-	);
-}

package/src/extensions/config/agent-config-parser.ts

@@ -1,198 +0,0 @@
-import type { AgentConfig, Tool } from "@clinebot/shared";
-import YAML from "yaml";
-import { z } from "zod";
-import { ALL_DEFAULT_TOOL_NAMES, type DefaultToolName } from "../tools/";
-
-const AgentConfigFrontmatterSchema = z.object({
-	name: z.string().trim().min(1),
-	description: z.string().trim().min(1),
-	modelId: z.string().trim().min(1).optional(),
-	tools: z.union([z.string(), z.array(z.string())]).optional(),
-	skills: z.union([z.string(), z.array(z.string())]).optional(),
-});
-
-const allowedToolNames = new Set<string>(ALL_DEFAULT_TOOL_NAMES);
-
-export interface AgentYamlConfig {
-	name: string;
-	description: string;
-	modelId?: string;
-	tools: DefaultToolName[];
-	skills?: string[];
-	systemPrompt: string;
-}
-
-export interface ParseYamlFrontmatterResult {
-	data: Record<string, unknown>;
-	body: string;
-	hadFrontmatter: boolean;
-	parseError?: string;
-}
-
-export interface BuildAgentConfigOverridesOptions {
-	availableTools?: ReadonlyArray<Tool>;
-}
-
-export interface PartialAgentConfigOverrides
-	extends Partial<Pick<AgentConfig, "modelId" | "systemPrompt" | "tools">> {
-	skills?: string[];
-}
-
-export function isAgentConfigYamlFile(fileName: string): boolean {
-	return /\.(yaml|yml)$/i.test(fileName);
-}
-
-export function normalizeAgentConfigName(name: string): string {
-	return name.trim().toLowerCase();
-}
-
-function parseYamlFrontmatter(markdown: string): ParseYamlFrontmatterResult {
-	const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-	const match = markdown.match(frontmatterRegex);
-	if (!match) {
-		return { data: {}, body: markdown, hadFrontmatter: false };
-	}
-
-	const [, yamlContent, body] = match;
-	try {
-		const parsed = YAML.parse(yamlContent);
-		const data =
-			parsed && typeof parsed === "object" && !Array.isArray(parsed)
-				? (parsed as Record<string, unknown>)
-				: {};
-		return { data, body, hadFrontmatter: true };
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return {
-			data: {},
-			body: markdown,
-			hadFrontmatter: true,
-			parseError: message,
-		};
-	}
-}
-
-function normalizeToolName(toolName: string): DefaultToolName {
-	const trimmed = toolName.trim();
-	if (!trimmed) {
-		throw new Error("Tool name cannot be empty.");
-	}
-	if (!allowedToolNames.has(trimmed)) {
-		throw new Error(
-			`Unknown tool '${trimmed}'. Expected one of: ${ALL_DEFAULT_TOOL_NAMES.join(", ")}.`,
-		);
-	}
-	return trimmed as DefaultToolName;
-}
-
-function parseToolNames(
-	tools: string | string[] | undefined,
-): DefaultToolName[] {
-	if (!tools) {
-		return [];
-	}
-	const rawTools = Array.isArray(tools) ? tools : tools.split(",");
-	return Array.from(new Set(rawTools.map(normalizeToolName)));
-}
-
-function normalizeSkillName(skillName: string): string {
-	const trimmed = skillName.trim();
-	if (!trimmed) {
-		throw new Error("Skill name cannot be empty.");
-	}
-	return trimmed;
-}
-
-function parseSkills(
-	skills: string | string[] | undefined,
-): string[] | undefined {
-	if (skills === undefined) {
-		return undefined;
-	}
-	const rawSkills = Array.isArray(skills) ? skills : skills.split(",");
-	return Array.from(new Set(rawSkills.map(normalizeSkillName)));
-}
-
-export function parseAgentConfigFromYaml(content: string): AgentYamlConfig {
-	const { data, body, hadFrontmatter, parseError } =
-		parseYamlFrontmatter(content);
-	if (parseError) {
-		throw new Error(`Failed to parse YAML frontmatter: ${parseError}`);
-	}
-	if (!hadFrontmatter) {
-		throw new Error("Missing YAML frontmatter block in agent config file.");
-	}
-
-	const parsedFrontmatter = AgentConfigFrontmatterSchema.parse(data);
-	const systemPrompt = body.trim();
-	if (!systemPrompt) {
-		throw new Error("Missing system prompt body in agent config file.");
-	}
-
-	return {
-		name: parsedFrontmatter.name,
-		description: parsedFrontmatter.description,
-		modelId: parsedFrontmatter.modelId,
-		tools: parseToolNames(parsedFrontmatter.tools),
-		skills: parseSkills(parsedFrontmatter.skills),
-		systemPrompt,
-	};
-}
-
-export function resolveAgentTools(
-	toolNames: ReadonlyArray<DefaultToolName>,
-	availableTools: ReadonlyArray<Tool>,
-): Tool[] {
-	if (toolNames.length === 0) {
-		return [];
-	}
-
-	const toolIndex = new Map<string, Tool>(
-		availableTools.map((tool) => [tool.name, tool]),
-	);
-	return toolNames.map((toolName) => {
-		const resolved = toolIndex.get(toolName);
-		if (!resolved) {
-			throw new Error(
-				`Configured tool '${toolName}' is unavailable. Available tools: ${availableTools.map((tool) => tool.name).join(", ")}.`,
-			);
-		}
-		return resolved;
-	});
-}
-
-export function toPartialAgentConfig(
-	config: AgentYamlConfig,
-	options?: BuildAgentConfigOverridesOptions,
-): PartialAgentConfigOverrides {
-	const partial: PartialAgentConfigOverrides = {
-		systemPrompt: config.systemPrompt,
-	};
-
-	if (config.modelId) {
-		partial.modelId = config.modelId;
-	}
-
-	if (config.tools.length > 0) {
-		if (!options?.availableTools) {
-			throw new Error(
-				"Configured tools cannot be converted into AgentConfig.tools without availableTools.",
-			);
-		}
-		partial.tools = resolveAgentTools(config.tools, options.availableTools);
-	}
-
-	if (config.skills !== undefined) {
-		partial.skills = [...config.skills];
-	}
-
-	return partial;
-}
-
-export function parsePartialAgentConfigFromYaml(
-	content: string,
-	options?: BuildAgentConfigOverridesOptions,
-): PartialAgentConfigOverrides {
-	const parsed = parseAgentConfigFromYaml(content);
-	return toPartialAgentConfig(parsed, options);
-}

package/src/extensions/config/hooks-config-loader.ts

@@ -1,117 +0,0 @@
-import { existsSync, readdirSync } from "node:fs";
-import { basename, extname, join } from "node:path";
-import {
-	HOOKS_CONFIG_DIRECTORY_NAME,
-	resolveHooksConfigSearchPaths as resolveHooksConfigSearchPathsFromShared,
-} from "@clinebot/shared/storage";
-import type { HookEventName } from "../../hooks";
-
-export { HOOKS_CONFIG_DIRECTORY_NAME };
-
-export function resolveHooksConfigSearchPaths(
-	workspacePath?: string,
-): string[] {
-	return resolveHooksConfigSearchPathsFromShared(workspacePath);
-}
-
-export enum HookConfigFileName {
-	TaskStart = "TaskStart",
-	TaskResume = "TaskResume",
-	TaskCancel = "TaskCancel",
-	TaskComplete = "TaskComplete",
-	TaskError = "TaskError",
-	PreToolUse = "PreToolUse",
-	PostToolUse = "PostToolUse",
-	UserPromptSubmit = "UserPromptSubmit",
-	PreCompact = "PreCompact",
-	SessionShutdown = "SessionShutdown",
-}
-
-export const HOOK_CONFIG_FILE_EVENT_MAP: Readonly<
-	Record<HookConfigFileName, HookEventName | undefined>
-> = {
-	[HookConfigFileName.TaskStart]: "agent_start",
-	[HookConfigFileName.TaskResume]: "agent_resume",
-	[HookConfigFileName.TaskCancel]: "agent_abort",
-	[HookConfigFileName.TaskComplete]: "agent_end",
-	[HookConfigFileName.TaskError]: "agent_error",
-	[HookConfigFileName.PreToolUse]: "tool_call",
-	[HookConfigFileName.PostToolUse]: "tool_result",
-	[HookConfigFileName.UserPromptSubmit]: "prompt_submit",
-	[HookConfigFileName.PreCompact]: undefined,
-	[HookConfigFileName.SessionShutdown]: "session_shutdown",
-};
-
-const HOOK_CONFIG_FILE_LOOKUP = new Map<string, HookConfigFileName>(
-	Object.values(HookConfigFileName).map((name) => [name.toLowerCase(), name]),
-);
-
-const SUPPORTED_HOOK_FILE_EXTENSIONS = new Set([
-	"",
-	".sh",
-	".bash",
-	".zsh",
-	".js",
-	".mjs",
-	".cjs",
-	".ts",
-	".mts",
-	".cts",
-	".py",
-	".ps1",
-]);
-
-export function toHookConfigFileName(
-	fileName: string,
-): HookConfigFileName | undefined {
-	const extension = extname(fileName).toLowerCase();
-	if (!SUPPORTED_HOOK_FILE_EXTENSIONS.has(extension)) {
-		return undefined;
-	}
-	const key = basename(fileName, extension).trim().toLowerCase();
-	return HOOK_CONFIG_FILE_LOOKUP.get(key);
-}
-
-export interface HookConfigFileEntry {
-	fileName: HookConfigFileName;
-	hookEventName?: HookEventName;
-	path: string;
-}
-
-export function listHookConfigFiles(
-	workspacePath?: string,
-): HookConfigFileEntry[] {
-	const entries: HookConfigFileEntry[] = [];
-	const seen = new Set<string>();
-	const directories = resolveHooksConfigSearchPaths(workspacePath).filter(
-		(directory) => existsSync(directory),
-	);
-
-	for (const directory of directories) {
-		try {
-			for (const entry of readdirSync(directory, { withFileTypes: true })) {
-				if (!entry.isFile()) {
-					continue;
-				}
-				const fileName = toHookConfigFileName(entry.name);
-				if (!fileName) {
-					continue;
-				}
-				const path = join(directory, entry.name);
-				if (seen.has(path)) {
-					continue;
-				}
-				seen.add(path);
-				entries.push({
-					fileName,
-					hookEventName: HOOK_CONFIG_FILE_EVENT_MAP[fileName],
-					path,
-				});
-			}
-		} catch {
-			// Best-effort listing across config roots.
-		}
-	}
-
-	return entries.sort((a, b) => a.path.localeCompare(b.path));
-}

package/src/extensions/config/index.ts

@@ -1,77 +0,0 @@
-export type {
-	AgentConfigWatcher,
-	AgentConfigWatcherEvent,
-	AgentYamlConfig,
-	BuildAgentConfigOverridesOptions,
-	CreateAgentConfigWatcherOptions,
-	ParseYamlFrontmatterResult,
-	PartialAgentConfigOverrides,
-} from "./agent-config-loader";
-export {
-	AGENT_CONFIG_DIRECTORY_NAME,
-	createAgentConfigDefinition,
-	createAgentConfigWatcher,
-	parseAgentConfigFromYaml,
-	parsePartialAgentConfigFromYaml,
-	readAgentConfigsFromDisk,
-	resolveAgentConfigSearchPaths,
-	resolveAgentsConfigDirPath,
-	resolveAgentTools,
-	toPartialAgentConfig,
-} from "./agent-config-loader";
-export {
-	HOOK_CONFIG_FILE_EVENT_MAP,
-	HOOKS_CONFIG_DIRECTORY_NAME,
-	type HookConfigFileEntry,
-	HookConfigFileName,
-	listHookConfigFiles,
-	resolveHooksConfigSearchPaths,
-	toHookConfigFileName,
-} from "./hooks-config-loader";
-export type {
-	AvailableRuntimeCommand,
-	RuntimeCommandKind,
-} from "./runtime-commands";
-export {
-	listAvailableRuntimeCommandsFromWatcher,
-	resolveRuntimeSlashCommandFromWatcher,
-} from "./runtime-commands";
-export type {
-	UnifiedConfigDefinition,
-	UnifiedConfigFileCandidate,
-	UnifiedConfigFileContext,
-	UnifiedConfigRecord,
-	UnifiedConfigWatcherEvent,
-	UnifiedConfigWatcherOptions,
-} from "./unified-config-file-watcher";
-export { UnifiedConfigFileWatcher } from "./unified-config-file-watcher";
-export type {
-	CreateInstructionWatcherOptions,
-	CreateRulesConfigDefinitionOptions,
-	CreateSkillsConfigDefinitionOptions,
-	CreateUserInstructionConfigWatcherOptions,
-	CreateWorkflowsConfigDefinitionOptions,
-	ParseMarkdownFrontmatterResult,
-	RuleConfig,
-	SkillConfig,
-	UserInstructionConfig,
-	UserInstructionConfigType,
-	UserInstructionConfigWatcher,
-	UserInstructionConfigWatcherEvent,
-	WorkflowConfig,
-} from "./user-instruction-config-loader";
-export {
-	createRulesConfigDefinition,
-	createSkillsConfigDefinition,
-	createUserInstructionConfigWatcher,
-	createWorkflowsConfigDefinition,
-	parseRuleConfigFromMarkdown,
-	parseSkillConfigFromMarkdown,
-	parseWorkflowConfigFromMarkdown,
-	RULES_CONFIG_DIRECTORY_NAME,
-	resolveRulesConfigSearchPaths,
-	resolveSkillsConfigSearchPaths,
-	resolveWorkflowsConfigSearchPaths,
-	SKILLS_CONFIG_DIRECTORY_NAME,
-	WORKFLOWS_CONFIG_DIRECTORY_NAME,
-} from "./user-instruction-config-loader";

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

@@ -1,82 +0,0 @@
-import { truncateSplit } from "@clinebot/shared";
-import type {
-	SkillConfig,
-	UserInstructionConfigWatcher,
-	WorkflowConfig,
-} from "./user-instruction-config-loader";
-
-export type RuntimeCommandKind = "skill" | "workflow";
-
-export type AvailableRuntimeCommand = {
-	id: string;
-	name: string;
-	instructions: string;
-	description?: string;
-	kind: RuntimeCommandKind;
-};
-
-type CommandRecord = {
-	item: SkillConfig | WorkflowConfig;
-};
-
-function isCommandEnabled(command: SkillConfig | WorkflowConfig): boolean {
-	return command.disabled !== true;
-}
-
-function listCommandsForKind(
-	watcher: UserInstructionConfigWatcher,
-	kind: RuntimeCommandKind,
-): AvailableRuntimeCommand[] {
-	return [...watcher.getSnapshot(kind).entries()]
-		.map(([id, record]) => ({ id, record: record as CommandRecord }))
-		.filter(({ record }) => isCommandEnabled(record.item))
-		.map(({ id, record }) => ({
-			id,
-			name: record.item.name,
-			instructions: record.item.instructions,
-			description: truncateSplit(
-				record.item.description ?? record.item.instructions,
-				".",
-			),
-			kind,
-		}))
-		.sort((a, b) => a.name.localeCompare(b.name));
-}
-
-export function listAvailableRuntimeCommandsFromWatcher(
-	watcher: UserInstructionConfigWatcher,
-): AvailableRuntimeCommand[] {
-	const byName = new Map<string, AvailableRuntimeCommand>();
-	for (const command of [
-		...listCommandsForKind(watcher, "workflow"),
-		...listCommandsForKind(watcher, "skill"),
-	]) {
-		if (!byName.has(command.name)) {
-			byName.set(command.name, command);
-		}
-	}
-	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-
-export function resolveRuntimeSlashCommandFromWatcher(
-	input: string,
-	watcher: UserInstructionConfigWatcher,
-): string {
-	if (!input.startsWith("/") || input.length < 2) {
-		return input;
-	}
-	const match = input.match(/^\/(\S+)/);
-	if (!match) {
-		return input;
-	}
-	const name = match[1];
-	if (!name) {
-		return input;
-	}
-	const commandLength = name.length + 1;
-	const remainder = input.slice(commandLength);
-	const matched = listAvailableRuntimeCommandsFromWatcher(watcher).find(
-		(command) => command.name === name,
-	);
-	return matched ? `${matched.instructions}${remainder}` : input;
-}