@schlenkr/ragents 0.1.4 → 0.1.6

package/packages/agent/src/core/prompt-templates.ts

@@ -1,284 +0,0 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { basename, dirname, join, resolve, sep } from "path";
-import { CONFIG_DIR_NAME } from "../config.ts";
-import { parseFrontmatter } from "../utils/frontmatter.ts";
-import { resolvePath } from "../utils/paths.ts";
-import { createSyntheticSourceInfo, type SourceInfo } from "./source-info.ts";
-
-/**
- * Represents a prompt template loaded from a markdown file
- */
-export interface PromptTemplate {
-	name: string;
-	description: string;
-	argumentHint?: string;
-	content: string;
-	sourceInfo: SourceInfo;
-	filePath: string; // Absolute path to the template file
-}
-
-/**
- * Parse command arguments respecting quoted strings (bash-style)
- * Returns array of arguments
- */
-export function parseCommandArgs(argsString: string): string[] {
-	const args: string[] = [];
-	let current = "";
-	let inQuote: string | null = null;
-
-	for (let i = 0; i < argsString.length; i++) {
-		const char = argsString[i];
-
-		if (inQuote) {
-			if (char === inQuote) {
-				inQuote = null;
-			} else {
-				current += char;
-			}
-		} else if (char === '"' || char === "'") {
-			inQuote = char;
-		} else if (/\s/.test(char)) {
-			if (current) {
-				args.push(current);
-				current = "";
-			}
-		} else {
-			current += char;
-		}
-	}
-
-	if (current) {
-		args.push(current);
-	}
-
-	return args;
-}
-
-/**
- * Substitute argument placeholders in template content
- * Supports:
- * - $1, $2, ... for positional args
- * - $@ and $ARGUMENTS for all args
- * - ${N:-default} for positional arg N with default when missing/empty
- * - ${@:N} for args from Nth onwards (bash-style slicing)
- * - ${@:N:L} for L args starting from Nth
- *
- * Note: Replacement happens on the template string only. Argument and default values
- * containing patterns like $1, $@, or $ARGUMENTS are NOT recursively substituted.
- */
-export function substituteArgs(content: string, args: string[]): string {
-	const allArgs = args.join(" ");
-
-	return content.replace(
-		/\$\{(\d+):-([^}]*)\}|\$\{@:(\d+)(?::(\d+))?\}|\$(ARGUMENTS|@|\d+)/g,
-		(_match, defaultNum, defaultValue, sliceStart, sliceLength, simple) => {
-			if (defaultNum) {
-				const index = parseInt(defaultNum, 10) - 1;
-				const value = args[index];
-				return value ? value : defaultValue;
-			}
-
-			if (sliceStart) {
-				let start = parseInt(sliceStart, 10) - 1; // Convert to 0-indexed (user provides 1-indexed)
-				// Treat 0 as 1 (bash convention: args start at 1)
-				if (start < 0) start = 0;
-
-				if (sliceLength) {
-					const length = parseInt(sliceLength, 10);
-					return args.slice(start, start + length).join(" ");
-				}
-				return args.slice(start).join(" ");
-			}
-
-			if (simple === "ARGUMENTS" || simple === "@") {
-				return allArgs;
-			}
-
-			const index = parseInt(simple, 10) - 1;
-			return args[index] ?? "";
-		},
-	);
-}
-
-function loadTemplateFromFile(filePath: string, sourceInfo: SourceInfo): PromptTemplate | null {
-	try {
-		const rawContent = readFileSync(filePath, "utf-8");
-		const { frontmatter, body } = parseFrontmatter<Record<string, string>>(rawContent);
-
-		const name = basename(filePath).replace(/\.md$/, "");
-
-		// Get description from frontmatter or first non-empty line
-		let description = frontmatter.description || "";
-		if (!description) {
-			const firstLine = body.split("\n").find((line) => line.trim());
-			if (firstLine) {
-				// Truncate if too long
-				description = firstLine.slice(0, 60);
-				if (firstLine.length > 60) description += "...";
-			}
-		}
-
-		return {
-			name,
-			description,
-			...(frontmatter["argument-hint"] && { argumentHint: frontmatter["argument-hint"] }),
-			content: body,
-			sourceInfo,
-			filePath,
-		};
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Scan a directory for .md files (non-recursive) and load them as prompt templates.
- */
-function loadTemplatesFromDir(dir: string, getSourceInfo: (filePath: string) => SourceInfo): PromptTemplate[] {
-	const templates: PromptTemplate[] = [];
-
-	if (!existsSync(dir)) {
-		return templates;
-	}
-
-	try {
-		const entries = readdirSync(dir, { withFileTypes: true });
-
-		for (const entry of entries) {
-			const fullPath = join(dir, entry.name);
-
-			// For symlinks, check if they point to a file
-			let isFile = entry.isFile();
-			if (entry.isSymbolicLink()) {
-				try {
-					const stats = statSync(fullPath);
-					isFile = stats.isFile();
-				} catch {
-					// Broken symlink, skip it
-					continue;
-				}
-			}
-
-			if (isFile && entry.name.endsWith(".md")) {
-				const template = loadTemplateFromFile(fullPath, getSourceInfo(fullPath));
-				if (template) {
-					templates.push(template);
-				}
-			}
-		}
-	} catch {
-		return templates;
-	}
-
-	return templates;
-}
-
-export interface LoadPromptTemplatesOptions {
-	/** Working directory for project-local templates. */
-	cwd: string;
-	/** Agent config directory for global templates. */
-	agentDir: string;
-	/** Explicit prompt template paths (files or directories). */
-	promptPaths: string[];
-	/** Include default prompt directories. */
-	includeDefaults: boolean;
-}
-
-/**
- * Load all prompt templates from:
- * 1. Global: agentDir/prompts/
- * 2. Project: cwd/{CONFIG_DIR_NAME}/prompts/
- * 3. Explicit prompt paths
- */
-export function loadPromptTemplates(options: LoadPromptTemplatesOptions): PromptTemplate[] {
-	const resolvedCwd = resolvePath(options.cwd);
-	const resolvedAgentDir = resolvePath(options.agentDir);
-	const promptPaths = options.promptPaths;
-	const includeDefaults = options.includeDefaults;
-
-	const templates: PromptTemplate[] = [];
-
-	const globalPromptsDir = join(resolvedAgentDir, "prompts");
-	const projectPromptsDir = resolve(resolvedCwd, CONFIG_DIR_NAME, "prompts");
-
-	const isUnderPath = (target: string, root: string): boolean => {
-		const normalizedRoot = resolve(root);
-		if (target === normalizedRoot) {
-			return true;
-		}
-		const prefix = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
-		return target.startsWith(prefix);
-	};
-
-	const getSourceInfo = (resolvedPath: string): SourceInfo => {
-		if (isUnderPath(resolvedPath, globalPromptsDir)) {
-			return createSyntheticSourceInfo(resolvedPath, {
-				source: "local",
-				scope: "user",
-				baseDir: globalPromptsDir,
-			});
-		}
-		if (isUnderPath(resolvedPath, projectPromptsDir)) {
-			return createSyntheticSourceInfo(resolvedPath, {
-				source: "local",
-				scope: "project",
-				baseDir: projectPromptsDir,
-			});
-		}
-		return createSyntheticSourceInfo(resolvedPath, {
-			source: "local",
-			baseDir: statSync(resolvedPath).isDirectory() ? resolvedPath : dirname(resolvedPath),
-		});
-	};
-
-	if (includeDefaults) {
-		templates.push(...loadTemplatesFromDir(globalPromptsDir, getSourceInfo));
-		templates.push(...loadTemplatesFromDir(projectPromptsDir, getSourceInfo));
-	}
-
-	// 3. Load explicit prompt paths
-	for (const rawPath of promptPaths) {
-		const resolvedPath = resolvePath(rawPath, resolvedCwd, { trim: true });
-		if (!existsSync(resolvedPath)) {
-			continue;
-		}
-
-		try {
-			const stats = statSync(resolvedPath);
-			if (stats.isDirectory()) {
-				templates.push(...loadTemplatesFromDir(resolvedPath, getSourceInfo));
-			} else if (stats.isFile() && resolvedPath.endsWith(".md")) {
-				const template = loadTemplateFromFile(resolvedPath, getSourceInfo(resolvedPath));
-				if (template) {
-					templates.push(template);
-				}
-			}
-		} catch {
-			// Ignore read failures
-		}
-	}
-
-	return templates;
-}
-
-/**
- * Expand a prompt template if it matches a template name.
- * Returns the expanded content or the original text if not a template.
- */
-export function expandPromptTemplate(text: string, templates: PromptTemplate[]): string {
-	if (!text.startsWith("/")) return text;
-
-	const match = text.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/);
-	if (!match) return text;
-
-	const templateName = match[1];
-	const argsString = match[2] ?? "";
-
-	const template = templates.find((t) => t.name === templateName);
-	if (template) {
-		const args = parseCommandArgs(argsString);
-		return substituteArgs(template.content, args);
-	}
-
-	return text;
-}

package/packages/agent/src/core/resolve-config-value.ts

@@ -1,287 +0,0 @@
-/**
- * Resolve configuration values that may be shell commands, environment variables, or literals.
- * Used by auth-storage.ts and model-registry.ts.
- */
-
-import { execSync, spawnSync } from "child_process";
-import { getShellConfig } from "../utils/shell.ts";
-
-// Cache for shell command results (persists for process lifetime)
-const commandResultCache = new Map<string, string | undefined>();
-const ENV_VAR_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const ENV_VAR_NAME_PREFIX_RE = /^[A-Za-z_][A-Za-z0-9_]*/;
-
-type TemplatePart = { type: "literal"; value: string } | { type: "env"; name: string };
-
-type ConfigValueReference = { type: "command"; config: string } | { type: "template"; parts: TemplatePart[] };
-
-function appendLiteral(parts: TemplatePart[], value: string): void {
-	if (!value) return;
-	const previousPart = parts[parts.length - 1];
-	if (previousPart?.type === "literal") {
-		previousPart.value += value;
-		return;
-	}
-	parts.push({ type: "literal", value });
-}
-
-function parseConfigValueTemplate(config: string): TemplatePart[] {
-	const parts: TemplatePart[] = [];
-	let index = 0;
-
-	while (index < config.length) {
-		const dollarIndex = config.indexOf("$", index);
-		if (dollarIndex < 0) {
-			appendLiteral(parts, config.slice(index));
-			break;
-		}
-
-		appendLiteral(parts, config.slice(index, dollarIndex));
-		const nextChar = config[dollarIndex + 1];
-
-		if (nextChar === "$" || nextChar === "!") {
-			appendLiteral(parts, nextChar);
-			index = dollarIndex + 2;
-			continue;
-		}
-
-		if (nextChar === "{") {
-			const endIndex = config.indexOf("}", dollarIndex + 2);
-			if (endIndex < 0) {
-				appendLiteral(parts, "$");
-				index = dollarIndex + 1;
-				continue;
-			}
-
-			const name = config.slice(dollarIndex + 2, endIndex);
-			if (ENV_VAR_NAME_RE.test(name)) {
-				parts.push({ type: "env", name });
-			} else {
-				appendLiteral(parts, config.slice(dollarIndex, endIndex + 1));
-			}
-			index = endIndex + 1;
-			continue;
-		}
-
-		const match = config.slice(dollarIndex + 1).match(ENV_VAR_NAME_PREFIX_RE);
-		if (match) {
-			parts.push({ type: "env", name: match[0] });
-			index = dollarIndex + 1 + match[0].length;
-			continue;
-		}
-
-		appendLiteral(parts, "$");
-		index = dollarIndex + 1;
-	}
-
-	return parts;
-}
-
-function parseConfigValueReference(config: string): ConfigValueReference {
-	if (config.startsWith("!")) {
-		return { type: "command", config };
-	}
-
-	return { type: "template", parts: parseConfigValueTemplate(config) };
-}
-
-function resolveEnvConfigValue(name: string, env?: Record<string, string>): string | undefined {
-	return env?.[name] || process.env[name] || undefined;
-}
-
-function getTemplateEnvVarNames(parts: TemplatePart[]): string[] {
-	const names: string[] = [];
-	for (const part of parts) {
-		if (part.type !== "env" || names.includes(part.name)) continue;
-		names.push(part.name);
-	}
-	return names;
-}
-
-function resolveTemplate(parts: TemplatePart[], env?: Record<string, string>): string | undefined {
-	let resolved = "";
-	for (const part of parts) {
-		if (part.type === "literal") {
-			resolved += part.value;
-			continue;
-		}
-		const envValue = resolveEnvConfigValue(part.name, env);
-		if (envValue === undefined) return undefined;
-		resolved += envValue;
-	}
-	return resolved;
-}
-
-export function getConfigValueEnvVarName(config: string): string | undefined {
-	const reference = parseConfigValueReference(config);
-	if (reference.type !== "template") return undefined;
-	return reference.parts.length === 1 && reference.parts[0]?.type === "env" ? reference.parts[0].name : undefined;
-}
-
-export function getConfigValueEnvVarNames(config: string): string[] {
-	const reference = parseConfigValueReference(config);
-	return reference.type === "template" ? getTemplateEnvVarNames(reference.parts) : [];
-}
-
-export function getMissingConfigValueEnvVarNames(config: string, env?: Record<string, string>): string[] {
-	return getConfigValueEnvVarNames(config).filter((name) => resolveEnvConfigValue(name, env) === undefined);
-}
-
-export function isCommandConfigValue(config: string): boolean {
-	return parseConfigValueReference(config).type === "command";
-}
-
-export function isConfigValueConfigured(config: string, env?: Record<string, string>): boolean {
-	return getMissingConfigValueEnvVarNames(config, env).length === 0;
-}
-
-/**
- * Resolve a config value (API key, header value, etc.) to an actual value.
- * - If starts with "!", executes the rest as a shell command and uses stdout (cached)
- * - Interpolates "$ENV_VAR" or "${ENV_VAR}" references with the named environment variable
- * - In non-command values, "$$" escapes a literal "$" and "$!" escapes a literal "!"
- * - Otherwise treats the value as a literal
- */
-export function resolveConfigValue(config: string, env?: Record<string, string>): string | undefined {
-	const reference = parseConfigValueReference(config);
-	if (reference.type === "command") {
-		return executeCommand(reference.config);
-	}
-	return resolveTemplate(reference.parts, env);
-}
-
-function executeWithConfiguredShell(command: string): { executed: boolean; value: string | undefined } {
-	try {
-		const { shell, args, commandTransport } = getShellConfig();
-		const commandFromStdin = commandTransport === "stdin";
-		const result = spawnSync(shell, commandFromStdin ? args : [...args, command], {
-			encoding: "utf-8",
-			input: commandFromStdin ? command : undefined,
-			timeout: 10000,
-			stdio: [commandFromStdin ? "pipe" : "ignore", "pipe", "ignore"],
-			shell: false,
-			windowsHide: true,
-		});
-
-		if (result.error) {
-			const error = result.error as NodeJS.ErrnoException;
-			if (error.code === "ENOENT") {
-				return { executed: false, value: undefined };
-			}
-			return { executed: true, value: undefined };
-		}
-
-		if (result.status !== 0) {
-			return { executed: true, value: undefined };
-		}
-
-		const value = (result.stdout ?? "").trim();
-		return { executed: true, value: value || undefined };
-	} catch {
-		return { executed: false, value: undefined };
-	}
-}
-
-function executeWithDefaultShell(command: string): string | undefined {
-	try {
-		const output = execSync(command, {
-			encoding: "utf-8",
-			timeout: 10000,
-			stdio: ["ignore", "pipe", "ignore"],
-		});
-		return output.trim() || undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-function executeCommandUncached(commandConfig: string): string | undefined {
-	const command = commandConfig.slice(1);
-	return process.platform === "win32"
-		? (() => {
-				const configuredResult = executeWithConfiguredShell(command);
-				return configuredResult.executed ? configuredResult.value : executeWithDefaultShell(command);
-			})()
-		: executeWithDefaultShell(command);
-}
-
-function executeCommand(commandConfig: string): string | undefined {
-	if (commandResultCache.has(commandConfig)) {
-		return commandResultCache.get(commandConfig);
-	}
-
-	const result = executeCommandUncached(commandConfig);
-	commandResultCache.set(commandConfig, result);
-	return result;
-}
-
-/**
- * Resolve all header values using the same resolution logic as API keys.
- */
-export function resolveConfigValueUncached(config: string, env?: Record<string, string>): string | undefined {
-	const reference = parseConfigValueReference(config);
-	if (reference.type === "command") {
-		return executeCommandUncached(reference.config);
-	}
-	return resolveTemplate(reference.parts, env);
-}
-
-export function resolveConfigValueOrThrow(config: string, description: string, env?: Record<string, string>): string {
-	const resolvedValue = resolveConfigValueUncached(config, env);
-	if (resolvedValue !== undefined) {
-		return resolvedValue;
-	}
-
-	const reference = parseConfigValueReference(config);
-	if (reference.type === "command") {
-		throw new Error(`Failed to resolve ${description} from shell command: ${reference.config.slice(1)}`);
-	}
-
-	if (reference.type === "template") {
-		const missingEnvVars = getMissingConfigValueEnvVarNames(config, env);
-		if (missingEnvVars.length === 1) {
-			throw new Error(`Failed to resolve ${description} from environment variable: ${missingEnvVars[0]}`);
-		}
-		if (missingEnvVars.length > 1) {
-			throw new Error(`Failed to resolve ${description} from environment variables: ${missingEnvVars.join(", ")}`);
-		}
-	}
-
-	throw new Error(`Failed to resolve ${description}`);
-}
-
-/**
- * Resolve all header values using the same resolution logic as API keys.
- */
-export function resolveHeaders(
-	headers: Record<string, string> | undefined,
-	env?: Record<string, string>,
-): Record<string, string> | undefined {
-	if (!headers) return undefined;
-	const resolved: Record<string, string> = {};
-	for (const [key, value] of Object.entries(headers)) {
-		const resolvedValue = resolveConfigValue(value, env);
-		if (resolvedValue) {
-			resolved[key] = resolvedValue;
-		}
-	}
-	return Object.keys(resolved).length > 0 ? resolved : undefined;
-}
-
-export function resolveHeadersOrThrow(
-	headers: Record<string, string> | undefined,
-	description: string,
-	env?: Record<string, string>,
-): Record<string, string> | undefined {
-	if (!headers) return undefined;
-	const resolved: Record<string, string> = {};
-	for (const [key, value] of Object.entries(headers)) {
-		resolved[key] = resolveConfigValueOrThrow(value, `${description} header "${key}"`, env);
-	}
-	return Object.keys(resolved).length > 0 ? resolved : undefined;
-}
-
-/** Clear the config value command cache. Exported for testing. */
-export function clearConfigValueCache(): void {
-	commandResultCache.clear();
-}

package/packages/agent/src/core/runtime-credentials.ts

@@ -1,48 +0,0 @@
-import type { Credential, CredentialInfo, CredentialStore } from "@aicontainer/ai";
-
-/** Async credential store overlay for non-persistent runtime API keys. */
-export class RuntimeCredentials implements CredentialStore {
-	private readonly store: CredentialStore;
-	private readonly overrides = new Map<string, string>();
-
-	constructor(store: CredentialStore) {
-		this.store = store;
-	}
-
-	setRuntimeApiKey(providerId: string, apiKey: string): void {
-		this.overrides.set(providerId, apiKey);
-	}
-
-	removeRuntimeApiKey(providerId: string): void {
-		this.overrides.delete(providerId);
-	}
-
-	hasRuntimeApiKey(providerId: string): boolean {
-		return this.overrides.has(providerId);
-	}
-
-	async read(providerId: string): Promise<Credential | undefined> {
-		const override = this.overrides.get(providerId);
-		return override ? { type: "api_key", key: override } : this.store.read(providerId);
-	}
-
-	async list(): Promise<readonly CredentialInfo[]> {
-		const entries = new Map((await this.store.list()).map((entry) => [entry.providerId, entry]));
-		for (const providerId of this.overrides.keys()) {
-			entries.set(providerId, { providerId, type: "api_key" });
-		}
-		return [...entries.values()];
-	}
-
-	modify(
-		providerId: string,
-		fn: (current: Credential | undefined) => Promise<Credential | undefined>,
-	): Promise<Credential | undefined> {
-		return this.store.modify(providerId, fn);
-	}
-
-	async delete(providerId: string): Promise<void> {
-		this.overrides.delete(providerId);
-		await this.store.delete(providerId);
-	}
-}

package/packages/agent/src/core/session-cwd.ts

@@ -1,59 +0,0 @@
-import { existsSync } from "node:fs";
-
-export interface SessionCwdIssue {
-	sessionFile?: string;
-	sessionCwd: string;
-	fallbackCwd: string;
-}
-
-interface SessionCwdSource {
-	getCwd(): string;
-	getSessionFile(): string | undefined;
-}
-
-export function getMissingSessionCwdIssue(
-	sessionManager: SessionCwdSource,
-	fallbackCwd: string,
-): SessionCwdIssue | undefined {
-	const sessionFile = sessionManager.getSessionFile();
-	if (!sessionFile) {
-		return undefined;
-	}
-
-	const sessionCwd = sessionManager.getCwd();
-	if (!sessionCwd || existsSync(sessionCwd)) {
-		return undefined;
-	}
-
-	return {
-		sessionFile,
-		sessionCwd,
-		fallbackCwd,
-	};
-}
-
-export function formatMissingSessionCwdError(issue: SessionCwdIssue): string {
-	const sessionFile = issue.sessionFile ? `\nSession file: ${issue.sessionFile}` : "";
-	return `Stored session working directory does not exist: ${issue.sessionCwd}${sessionFile}\nCurrent working directory: ${issue.fallbackCwd}`;
-}
-
-export function formatMissingSessionCwdPrompt(issue: SessionCwdIssue): string {
-	return `cwd from session file does not exist\n${issue.sessionCwd}\n\ncontinue in current cwd\n${issue.fallbackCwd}`;
-}
-
-export class MissingSessionCwdError extends Error {
-	readonly issue: SessionCwdIssue;
-
-	constructor(issue: SessionCwdIssue) {
-		super(formatMissingSessionCwdError(issue));
-		this.name = "MissingSessionCwdError";
-		this.issue = issue;
-	}
-}
-
-export function assertSessionCwdExists(sessionManager: SessionCwdSource, fallbackCwd: string): void {
-	const issue = getMissingSessionCwdIssue(sessionManager, fallbackCwd);
-	if (issue) {
-		throw new MissingSessionCwdError(issue);
-	}
-}