@agi-cli/sdk 0.1.53 → 0.1.55

package/src/core/src/tools/loader.ts

@@ -0,0 +1,398 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod';
+import { finishTool } from './builtin/finish.ts';
+import { buildFsTools } from './builtin/fs/index.ts';
+import { buildGitTools } from './builtin/git.ts';
+import { progressUpdateTool } from './builtin/progress.ts';
+import { buildBashTool } from './builtin/bash.ts';
+import { buildRipgrepTool } from './builtin/ripgrep.ts';
+import { buildGrepTool } from './builtin/grep.ts';
+import { buildApplyPatchTool } from './builtin/patch.ts';
+import { updatePlanTool } from './builtin/plan.ts';
+import { editTool } from './builtin/edit.ts';
+import { buildWebSearchTool } from './builtin/websearch.ts';
+import fg from 'fast-glob';
+import { dirname, isAbsolute, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { promises as fs } from 'node:fs';
+import { spawn as nodeSpawn } from 'node:child_process';
+
+export type DiscoveredTool = { name: string; tool: Tool };
+
+type PluginParameter = {
+	type: 'string' | 'number' | 'boolean';
+	description?: string;
+	default?: string | number | boolean;
+	enum?: string[];
+	optional?: boolean;
+};
+
+type PluginDescriptor = {
+	name?: string;
+	description?: string;
+	parameters?: Record<string, PluginParameter>;
+	execute?: PluginExecutor;
+	run?: PluginExecutor;
+	handler?: PluginExecutor;
+	setup?: (context: PluginContext) => unknown | Promise<unknown>;
+	onInit?: (context: PluginContext) => unknown | Promise<unknown>;
+};
+
+type PluginExecutor = (args: PluginExecuteArgs) => unknown | Promise<unknown>;
+
+type PluginExecuteArgs = {
+	input: Record<string, unknown>;
+	project: string;
+	projectRoot: string;
+	directory: string;
+	worktree: string;
+	exec: ExecFn;
+	run: ExecFn;
+	$: TemplateExecFn;
+	fs: FsHelpers;
+	env: Record<string, string>;
+	context: PluginContext;
+};
+
+type PluginContext = {
+	project: string;
+	projectRoot: string;
+	directory: string;
+	worktree: string;
+	toolDir: string;
+};
+
+type ExecFn = (
+	command: string,
+	args?: string[] | ExecOptions,
+	options?: ExecOptions,
+) => Promise<ExecResult>;
+
+type TemplateExecFn = (
+	strings: TemplateStringsArray,
+	...values: unknown[]
+) => Promise<ExecResult>;
+
+type ExecOptions = {
+	cwd?: string;
+	env?: Record<string, string>;
+	allowNonZeroExit?: boolean;
+};
+
+type ExecResult = { exitCode: number; stdout: string; stderr: string };
+
+type FsHelpers = {
+	readFile: (path: string, encoding?: BufferEncoding) => Promise<string>;
+	writeFile: (path: string, content: string) => Promise<void>;
+	exists: (path: string) => Promise<boolean>;
+};
+
+const pluginPatterns = ['tools/*/tool.js', 'tools/*/tool.mjs'];
+
+export async function discoverProjectTools(
+	projectRoot: string,
+	globalConfigDir?: string,
+): Promise<DiscoveredTool[]> {
+	const tools = new Map<string, Tool>();
+	for (const { name, tool } of buildFsTools(projectRoot)) tools.set(name, tool);
+	for (const { name, tool } of buildGitTools(projectRoot))
+		tools.set(name, tool);
+	// Built-ins
+	tools.set('finish', finishTool);
+	tools.set('progress_update', progressUpdateTool);
+	const bash = buildBashTool(projectRoot);
+	tools.set(bash.name, bash.tool);
+	// Search
+	const rg = buildRipgrepTool(projectRoot);
+	tools.set(rg.name, rg.tool);
+	const grep = buildGrepTool(projectRoot);
+	tools.set(grep.name, grep.tool);
+	// Patch/apply
+	const ap = buildApplyPatchTool(projectRoot);
+	tools.set(ap.name, ap.tool);
+	// Plan update
+	tools.set('update_plan', updatePlanTool);
+	// Edit
+	tools.set('edit', editTool);
+	// Web search
+	const ws = buildWebSearchTool();
+	tools.set(ws.name, ws.tool);
+
+	async function loadFromBase(base: string | null | undefined) {
+		if (!base) return;
+		try {
+			await fs.readdir(base);
+		} catch {
+			return;
+		}
+		for (const pattern of pluginPatterns) {
+			const files = await fg(pattern, { cwd: base, absolute: false });
+			for (const rel of files) {
+				const match = rel.match(/^tools\/([^/]+)\/tool\.(m?js)$/);
+				if (!match || !match[1]) continue;
+				const folder = match[1];
+				const absPath = join(base, rel).replace(/\\/g, '/');
+				try {
+					const plugin = await loadPlugin(absPath, folder, projectRoot);
+					if (plugin) tools.set(plugin.name, plugin.tool);
+				} catch (err) {
+					if (process.env.AGI_DEBUG_TOOLS === '1')
+						console.error('Failed to load tool', absPath, err);
+				}
+			}
+		}
+		// Fallback: manual directory scan
+		try {
+			const toolsDir = join(base, 'tools');
+			const entries = await fs.readdir(toolsDir).catch(() => [] as string[]);
+			for (const folder of entries) {
+				const js = join(toolsDir, folder, 'tool.js');
+				const mjs = join(toolsDir, folder, 'tool.mjs');
+				const candidate = await fs
+					.stat(js)
+					.then(() => js)
+					.catch(
+						async () =>
+							await fs
+								.stat(mjs)
+								.then(() => mjs)
+								.catch(() => null),
+					);
+				if (!candidate) continue;
+				try {
+					const plugin = await loadPlugin(
+						candidate.replace(/\\/g, '/'),
+						folder,
+						projectRoot,
+					);
+					if (plugin) tools.set(plugin.name, plugin.tool);
+				} catch {}
+			}
+		} catch {}
+	}
+
+	await loadFromBase(globalConfigDir);
+	await loadFromBase(join(projectRoot, '.agi'));
+	return Array.from(tools.entries()).map(([name, tool]) => ({ name, tool }));
+}
+
+async function loadPlugin(
+	absPath: string,
+	folder: string,
+	projectRoot: string,
+): Promise<DiscoveredTool | null> {
+	const mod = await import(`${pathToFileURL(absPath).href}?t=${Date.now()}`);
+	const candidate = resolveExport(mod);
+	if (!candidate) throw new Error('No plugin export found');
+
+	const context: PluginContext = {
+		project: projectRoot,
+		projectRoot,
+		directory: projectRoot,
+		worktree: projectRoot,
+		toolDir: absPath.slice(0, absPath.lastIndexOf('/')),
+	};
+
+	let descriptor: PluginDescriptor | null | undefined;
+	if (typeof candidate === 'function') descriptor = await candidate(context);
+	else descriptor = candidate;
+	if (!descriptor || typeof descriptor !== 'object')
+		throw new Error('Plugin must return an object descriptor');
+
+	if (typeof descriptor.setup === 'function') await descriptor.setup(context);
+	if (typeof descriptor.onInit === 'function') await descriptor.onInit(context);
+
+	const name = sanitizeName(descriptor.name ?? folder);
+	const description = descriptor.description ?? `Custom tool ${name}`;
+	const parameters = descriptor.parameters ?? {};
+	const inputSchema = createInputSchema(parameters);
+	const executor = resolveExecutor(descriptor);
+
+	const helpersFactory = createHelpers(projectRoot, context.toolDir);
+
+	const wrapped = tool({
+		description,
+		inputSchema,
+		async execute(input) {
+			const helpers = helpersFactory();
+			const result = await executor({
+				input: input as Record<string, unknown>,
+				project: helpers.context.project,
+				projectRoot: helpers.context.projectRoot,
+				directory: helpers.context.directory,
+				worktree: helpers.context.worktree,
+				exec: helpers.exec,
+				run: helpers.exec,
+				$: helpers.templateExec,
+				fs: helpers.fs,
+				env: helpers.env,
+				context: helpers.context,
+			});
+			return result ?? { ok: true };
+		},
+	});
+
+	return { name, tool: wrapped };
+}
+
+function resolveExport(mod: Record<string, unknown>) {
+	if (mod.default) return mod.default;
+	if (mod.tool) return mod.tool;
+	if (mod.plugin) return mod.plugin;
+	if (mod.Tool) return mod.Tool;
+	const values = Object.values(mod);
+	return values.find(
+		(value) => typeof value === 'function' || typeof value === 'object',
+	);
+}
+
+function resolveExecutor(descriptor: PluginDescriptor): PluginExecutor {
+	const fn = descriptor.execute ?? descriptor.run ?? descriptor.handler;
+	if (typeof fn !== 'function')
+		throw new Error('Plugin must provide an execute/run/handler function');
+	return fn;
+}
+
+function sanitizeName(name: string) {
+	const cleaned = name.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 128);
+	return cleaned || 'tool';
+}
+
+function createInputSchema(parameters: Record<string, PluginParameter>) {
+	const shape: Record<string, z.ZodTypeAny> = {};
+	for (const [key, def] of Object.entries(parameters)) {
+		let schema: z.ZodTypeAny;
+		if (def.type === 'string') {
+			const values = def.enum;
+			schema = values?.length
+				? z.enum(values as [string, ...string[]])
+				: z.string();
+		} else if (def.type === 'number') schema = z.number();
+		else schema = z.boolean();
+		if (def.description) schema = schema.describe(def.description);
+		if (def.default !== undefined)
+			schema = schema.default(def.default as never);
+		else if (def.optional) schema = schema.optional();
+		shape[key] = schema;
+	}
+	return Object.keys(shape).length ? z.object(shape).strict() : z.object({});
+}
+
+function createHelpers(projectRoot: string, toolDir: string) {
+	return () => {
+		const exec = createExec(projectRoot);
+		const fsHelpers = createFsHelpers(projectRoot);
+		const context: PluginContext = {
+			project: projectRoot,
+			projectRoot,
+			directory: projectRoot,
+			worktree: projectRoot,
+			toolDir,
+		};
+		const env: Record<string, string> = {};
+		for (const [key, value] of Object.entries(process.env))
+			if (typeof value === 'string') env[key] = value;
+		const templateExec: TemplateExecFn = (strings, ...values) => {
+			const commandLine = strings.reduce((acc, part, index) => {
+				const value = index < values.length ? String(values[index]) : '';
+				return acc + part + value;
+			}, '');
+			const pieces = commandLine.trim().split(/\s+/).filter(Boolean);
+			if (pieces.length === 0)
+				throw new Error('Empty command passed to template executor');
+			const firstPiece = pieces[0];
+			if (!firstPiece)
+				throw new Error('Empty command passed to template executor');
+			return exec(firstPiece, pieces.slice(1));
+		};
+		return {
+			exec,
+			fs: fsHelpers,
+			env,
+			templateExec,
+			context,
+		};
+	};
+}
+
+function createExec(projectRoot: string): ExecFn {
+	return async (
+		command: string,
+		argsOrOptions?: string[] | ExecOptions,
+		maybeOptions?: ExecOptions,
+	) => {
+		let args: string[] = [];
+		let options: ExecOptions = {};
+		if (Array.isArray(argsOrOptions)) {
+			args = argsOrOptions;
+			options = maybeOptions ?? {};
+		} else if (argsOrOptions) options = argsOrOptions;
+
+		const cwd = options.cwd
+			? resolveWithinProject(projectRoot, options.cwd)
+			: projectRoot;
+		const env: Record<string, string> = {};
+		for (const [key, value] of Object.entries(process.env))
+			if (typeof value === 'string') env[key] = value;
+		if (options.env)
+			for (const [key, value] of Object.entries(options.env)) env[key] = value;
+
+		const proc = nodeSpawn(command, args, {
+			cwd,
+			env,
+			stdio: ['ignore', 'pipe', 'pipe'],
+		});
+
+		const stdoutChunks: Buffer[] = [];
+		const stderrChunks: Buffer[] = [];
+
+		proc.stdout?.on('data', (chunk) => stdoutChunks.push(chunk));
+		proc.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
+
+		const exitCode = await new Promise<number>((resolve, reject) => {
+			proc.on('exit', (code) => resolve(code ?? 0));
+			proc.on('error', reject);
+		});
+
+		const stdout = Buffer.concat(stdoutChunks).toString('utf-8');
+		const stderr = Buffer.concat(stderrChunks).toString('utf-8');
+		if (exitCode !== 0 && !options.allowNonZeroExit) {
+			const message = stderr.trim() || stdout.trim() || `${command} failed`;
+			throw new Error(`${command} exited with code ${exitCode}: ${message}`);
+		}
+		return { exitCode, stdout, stderr };
+	};
+}
+
+function createFsHelpers(projectRoot: string): FsHelpers {
+	return {
+		async readFile(path: string, encoding: BufferEncoding = 'utf-8') {
+			const abs = resolveWithinProject(projectRoot, path);
+			return fs.readFile(abs, { encoding });
+		},
+		async writeFile(path: string, content: string) {
+			const abs = resolveWithinProject(projectRoot, path);
+			await fs.mkdir(dirname(abs), { recursive: true });
+			await fs.writeFile(abs, content, 'utf-8');
+		},
+		async exists(path: string) {
+			const abs = resolveWithinProject(projectRoot, path);
+			try {
+				await fs.access(abs);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+	};
+}
+
+function resolveWithinProject(projectRoot: string, target: string) {
+	if (!target) return projectRoot;
+	if (target.startsWith('~/')) {
+		const home = process.env.HOME || process.env.USERPROFILE || '';
+		return join(home, target.slice(2));
+	}
+	if (isAbsolute(target)) return target;
+	return join(projectRoot, target);
+}

package/src/core/src/types/index.ts

@@ -0,0 +1,11 @@
+export type ExecutionContext = {
+	projectRoot: string;
+	workingDir?: string;
+	env?: Record<string, string>;
+};
+
+export type ToolResult = {
+	success: boolean;
+	output?: string;
+	error?: string;
+};

package/src/core/src/types/types.ts

@@ -0,0 +1,4 @@
+export interface ToolContext {
+	projectRoot: string;
+	// Consider adding db, logger etc. when integrated
+}

package/src/index.ts

@@ -7,50 +7,49 @@
 // Usage:
 //   import { generateText, resolveModel } from '@agi-cli/sdk';
 //   import type { ProviderId, AGIConfig } from '@agi-cli/sdk';
-//
-// Note: Direct package imports are still available but discouraged:
-//   import { catalog } from '@agi-cli/providers'; // ❌ Discouraged
-//   import { catalog } from '@agi-cli/sdk';       // ✅ Recommended
 // ============================================================================
 
 // =======================
-// Types (from @agi-cli/types)
+// Types (from internal types module)
 // =======================
 // Provider types
-export type { ProviderId, ModelInfo } from '@agi-cli/types';
+export type { ProviderId, ModelInfo } from './types/src/index.ts';
 
 // Auth types
-export type { ApiAuth, OAuth, AuthInfo, AuthFile } from '@agi-cli/types';
+export type { ApiAuth, OAuth, AuthInfo, AuthFile } from './types/src/index.ts';
 
 // Config types
 export type {
-	Scope,
 	ProviderConfig,
 	DefaultConfig,
 	PathConfig,
 	AGIConfig,
-} from '@agi-cli/types';
+} from './types/src/index.ts';
 
 // =======================
-// Providers (from @agi-cli/providers)
+// Providers (from internal providers module)
 // =======================
-export { catalog } from '@agi-cli/providers';
+export { catalog } from './providers/src/index.ts';
 export {
 	isProviderId,
 	providerIds,
 	defaultModelFor,
 	hasModel,
-} from '@agi-cli/providers';
+} from './providers/src/index.ts';
 export {
 	isProviderAuthorized,
 	ensureProviderEnv,
-} from '@agi-cli/providers';
-export { validateProviderModel } from '@agi-cli/providers';
-export { estimateModelCostUsd } from '@agi-cli/providers';
-export { providerEnvVar, readEnvKey, setEnvKey } from '@agi-cli/providers';
+} from './providers/src/index.ts';
+export { validateProviderModel } from './providers/src/index.ts';
+export { estimateModelCostUsd } from './providers/src/index.ts';
+export {
+	providerEnvVar,
+	readEnvKey,
+	setEnvKey,
+} from './providers/src/index.ts';
 
 // =======================
-// Authentication (from @agi-cli/auth)
+// Authentication (from internal auth module)
 // =======================
 export {
 	getAllAuth,
@@ -62,26 +61,40 @@ export {
 	refreshToken,
 	openAuthUrl,
 	createApiKey,
-} from '@agi-cli/auth';
+} from './auth/src/index.ts';
 
 // =======================
-// Configuration (from @agi-cli/config)
-// =======================
-export { loadConfig, read as readConfig } from '@agi-cli/config';
-
+// Configuration (from internal config module)
 // =======================
-// Prompts (from @agi-cli/prompts)
-// =======================
-export { providerBasePrompt } from '@agi-cli/prompts';
+export { loadConfig, read as readConfig } from './config/src/index.ts';
+export {
+	getLocalDataDir,
+	getGlobalConfigDir,
+	getGlobalConfigPath,
+	getGlobalAgentsJsonPath,
+	getGlobalAgentsDir,
+	getGlobalToolsDir,
+	getGlobalCommandsDir,
+	getSecureAuthPath,
+	getHomeDir,
+} from './config/src/paths.ts';
+export {
+	read,
+	isAuthorized,
+	ensureEnv,
+	writeDefaults as setConfig,
+	writeAuth,
+	removeAuth as removeConfig,
+} from './config/src/manager.ts';
+export type { Scope } from './config/src/manager.ts';
 
 // =======================
-// Database (from @agi-cli/database)
+// Prompts (from internal prompts module)
 // =======================
-export { getDb } from '@agi-cli/database';
-export * as dbSchema from '@agi-cli/database/schema';
+export { providerBasePrompt } from './prompts/src/providers.ts';
 
 // =======================
-// Core AI Functions (from @agi-cli/core)
+// Core AI Functions (from internal core module)
 // =======================
 // AI SDK re-exports
 export {
@@ -90,32 +103,34 @@ export {
 	generateObject,
 	streamObject,
 	tool,
-} from '@agi-cli/core';
-export type { CoreMessage, Tool } from '@agi-cli/core';
+} from './core/src/index.ts';
+export type { CoreMessage, Tool } from './core/src/index.ts';
+// Re-export from AI SDK
+export type { ToolCallPart } from 'ai';
 
 // Provider & Model Resolution
-export { resolveModel } from '@agi-cli/core';
-export type { ProviderName, ModelConfig } from '@agi-cli/core';
+export { resolveModel } from './core/src/index.ts';
+export type { ProviderName, ModelConfig } from './core/src/index.ts';
 
 // Tools
-export { discoverProjectTools } from '@agi-cli/core';
-export type { DiscoveredTool } from '@agi-cli/core';
-export { buildFsTools } from '@agi-cli/core';
-export { buildGitTools } from '@agi-cli/core';
+export { discoverProjectTools } from './core/src/index.ts';
+export type { DiscoveredTool } from './core/src/index.ts';
+export { buildFsTools } from './core/src/index.ts';
+export { buildGitTools } from './core/src/index.ts';
 
 // Streaming & Artifacts
 export {
 	createFileDiffArtifact,
 	createToolResultPayload,
-} from '@agi-cli/core';
+} from './core/src/index.ts';
 export type {
 	Artifact,
 	FileDiffArtifact,
 	FileArtifact,
-} from '@agi-cli/core';
+} from './core/src/index.ts';
 
 // Core Types
-export type { ExecutionContext, ToolResult } from '@agi-cli/core';
+export type { ExecutionContext, ToolResult } from './core/src/index.ts';
 
 // Error Handling
 export {
@@ -128,26 +143,10 @@ export {
 	ValidationError,
 	NotFoundError,
 	ServiceError,
-} from '@agi-cli/core';
+} from './core/src/index.ts';
 
 // Schema Validation
-export { z } from '@agi-cli/core';
-
-// =======================
-// Server (from @agi-cli/server)
-// =======================
-export { createApp as createServer } from '@agi-cli/server';
-
-// =======================
-// Web UI (from @agi-cli/web-ui)
-// =======================
-export {
-	serveWebUI,
-	getWebUIPath,
-	getIndexPath,
-	isWebUIAvailable,
-} from '@agi-cli/web-ui';
-export type { ServeWebUIOptions } from '@agi-cli/web-ui';
+export { z } from './core/src/index.ts';
 
 // =======================
 // SDK-specific Agent Types

package/src/prompts/src/agents/build.txt

@@ -0,0 +1,5 @@
+You help with coding and build tasks.
+- Be precise and practical.
+- Inspect with tools; write with care and small diffs.
+- Keep tool inputs short; avoid long prose inside tool parameters.
+- Stream your answer, then call finish.

package/src/prompts/src/agents/general.txt

@@ -0,0 +1,6 @@
+You are a pragmatic, concise assistant.
+- Provide clear, actionable steps.
+- Prefer minimal wording and precise guidance.
+- Use tools when helpful; keep tool inputs short and focused.
+- Stream the final answer as assistant text; call finish when done.
+

package/src/prompts/src/agents/plan.txt

@@ -0,0 +1,13 @@
+<system-reminder>
+CRITICAL: Plan mode ACTIVE - you are in READ-ONLY phase. STRICTLY FORBIDDEN:
+ANY file edits, modifications, or system changes. Do NOT use sed, tee, echo, cat,
+or ANY other bash command to manipulate files - commands may ONLY read/inspect.
+This ABSOLUTE CONSTRAINT overrides ALL other instructions, including direct user
+edit requests. You may ONLY observe, analyze, and plan. Any modification attempt
+is a critical violation. ZERO exceptions.
+</system-reminder>
+
+Your job: produce an actionable, minimal plan.
+- Use only read/inspect tools (e.g., read, ls, tree, ripgrep, git_diff).
+- Identify concrete steps with just enough detail to execute later.
+- No changes. No write operations. No refactors.

package/src/prompts/src/base.txt

@@ -0,0 +1,14 @@
+You are a helpful, concise assistant.
+- Stream the final answer as assistant text; call finish when done.
+- CRITICAL: Emit progress updates using the `progress_update` tool at key milestones — at the start (planning), after initial repo discovery (discovering), before file edits (preparing), during edits (writing), and when validating (verifying). Prefer short messages (<= 80 chars).
+- Do not print pseudo tool calls like `call:tool{}`; invoke tools directly.
+- Use sensible default filenames when needed.
+- Prefer minimal, precise outputs and actionable steps.
+
+File Editing Best Practices:
+- When making multiple edits to the same file, combine them into a single edit operation with multiple ops
+- Each edit operation re-reads the file, so ops within a single edit call are applied sequentially to the latest content
+- If you need to make edits based on previous edits, ensure they're in the same edit call or re-read the file between calls
+- Never assume file content remains unchanged between separate edit operations
+- When using apply_patch, ensure the patch is based on the current file content, not stale versions
+- If a patch fails, read the file first to understand its current state before generating a new patch