lcagent-cli 0.1.0

package/dist/core/message.d.ts

@@ -0,0 +1,38 @@
+export type TextBlock = {
+    type: 'text';
+    text: string;
+};
+export type ToolUseBlock = {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: unknown;
+};
+export type ToolResultBlock = {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+};
+export type AgentContentBlock = TextBlock | ToolUseBlock | ToolResultBlock;
+export type AgentMessage = {
+    role: 'user' | 'assistant';
+    content: AgentContentBlock[];
+};
+export type AgentEvent = {
+    type: 'status';
+    message: string;
+} | {
+    type: 'assistant_text';
+    text: string;
+} | {
+    type: 'tool_call';
+    toolName: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    toolName: string;
+    result: string;
+    isError?: boolean;
+};
+export declare function createUserTextMessage(text: string): AgentMessage;

package/dist/core/message.js

@@ -0,0 +1,6 @@
+export function createUserTextMessage(text) {
+    return {
+        role: 'user',
+        content: [{ type: 'text', text }],
+    };
+}

package/dist/core/model.d.ts

@@ -0,0 +1,28 @@
+import type { AgentMessage, ToolUseBlock } from './message.js';
+import { type ToolDefinition } from '../tools/types.js';
+export type ModelClientConfig = {
+    provider: 'anthropic' | 'openai-compatible';
+    apiKey?: string;
+    baseUrl: string;
+    model: string;
+    maxTokens: number;
+};
+export type ModelResponse = {
+    id: string;
+    stopReason: string | null;
+    content: Array<{
+        type: 'text';
+        text: string;
+    } | ToolUseBlock>;
+};
+export declare class ModelClient {
+    private readonly config;
+    constructor(config: ModelClientConfig);
+    createMessage(params: {
+        systemPrompt: string;
+        messages: AgentMessage[];
+        tools: ToolDefinition[];
+    }): Promise<ModelResponse>;
+    private createAnthropicMessage;
+    private createOpenAICompatibleMessage;
+}

package/dist/core/model.js

@@ -0,0 +1,158 @@
+import { toAnthropicTool, toOpenAICompatibleTool, } from '../tools/types.js';
+function textFromBlocks(blocks) {
+    return blocks
+        .filter((block) => block.type === 'text')
+        .map(block => block.text)
+        .join('\n');
+}
+function toolUsesFromBlocks(blocks) {
+    return blocks.filter((block) => block.type === 'tool_use');
+}
+function toOpenAICompatibleMessages(systemPrompt, messages) {
+    const converted = [
+        {
+            role: 'system',
+            content: systemPrompt,
+        },
+    ];
+    for (const message of messages) {
+        if (message.role === 'assistant') {
+            const text = textFromBlocks(message.content);
+            const toolUses = toolUsesFromBlocks(message.content);
+            converted.push({
+                role: 'assistant',
+                content: text || undefined,
+                ...(toolUses.length > 0
+                    ? {
+                        tool_calls: toolUses.map(toolUse => ({
+                            id: toolUse.id,
+                            type: 'function',
+                            function: {
+                                name: toolUse.name,
+                                arguments: JSON.stringify(toolUse.input),
+                            },
+                        })),
+                    }
+                    : {}),
+            });
+            continue;
+        }
+        const toolResults = message.content.filter((block) => block.type === 'tool_result');
+        if (toolResults.length > 0) {
+            for (const toolResult of toolResults) {
+                converted.push({
+                    role: 'tool',
+                    tool_call_id: toolResult.tool_use_id,
+                    content: toolResult.content,
+                });
+            }
+            continue;
+        }
+        converted.push({
+            role: 'user',
+            content: textFromBlocks(message.content),
+        });
+    }
+    return converted;
+}
+function parseToolArguments(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return { raw };
+    }
+}
+export class ModelClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async createMessage(params) {
+        if (this.config.provider === 'openai-compatible') {
+            return this.createOpenAICompatibleMessage(params);
+        }
+        return this.createAnthropicMessage(params);
+    }
+    async createAnthropicMessage(params) {
+        const url = `${this.config.baseUrl.replace(/\/+$/, '')}/v1/messages`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...(this.config.apiKey ? { 'x-api-key': this.config.apiKey } : {}),
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+                model: this.config.model,
+                max_tokens: this.config.maxTokens,
+                system: params.systemPrompt,
+                messages: params.messages,
+                tools: params.tools.map(toAnthropicTool),
+            }),
+        });
+        const data = (await response.json());
+        if (!response.ok) {
+            const detail = data.error?.message ?? `HTTP ${response.status}`;
+            throw new Error(`Model API request failed: ${detail}`);
+        }
+        return {
+            id: data.id,
+            stopReason: data.stop_reason,
+            content: data.content.map(block => {
+                if (block.type === 'tool_use') {
+                    return {
+                        type: 'tool_use',
+                        id: block.id,
+                        name: block.name,
+                        input: block.input,
+                    };
+                }
+                return block;
+            }),
+        };
+    }
+    async createOpenAICompatibleMessage(params) {
+        const url = `${this.config.baseUrl.replace(/\/+$/, '')}/chat/completions`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...(this.config.apiKey
+                    ? { Authorization: `Bearer ${this.config.apiKey}` }
+                    : {}),
+            },
+            body: JSON.stringify({
+                model: this.config.model,
+                messages: toOpenAICompatibleMessages(params.systemPrompt, params.messages),
+                tools: params.tools.map(toOpenAICompatibleTool),
+                tool_choice: 'auto',
+                max_tokens: this.config.maxTokens,
+            }),
+        });
+        const data = (await response.json());
+        if (!response.ok) {
+            const detail = data.error?.message ?? `HTTP ${response.status}`;
+            throw new Error(`Model API request failed: ${detail}`);
+        }
+        const choice = data.choices[0];
+        if (!choice) {
+            throw new Error('Model API request failed: empty choices array');
+        }
+        return {
+            id: data.id,
+            stopReason: choice.finish_reason,
+            content: [
+                ...(choice.message.content
+                    ? [{ type: 'text', text: choice.message.content }]
+                    : []),
+                ...((choice.message.tool_calls ?? []).map(toolCall => ({
+                    type: 'tool_use',
+                    id: toolCall.id,
+                    name: toolCall.function.name,
+                    input: parseToolArguments(toolCall.function.arguments),
+                }))),
+            ],
+        };
+    }
+}

package/dist/core/systemPrompt.d.ts

@@ -0,0 +1 @@
+export declare function buildSystemPrompt(cwd: string): string;

package/dist/core/systemPrompt.js

@@ -0,0 +1,11 @@
+export function buildSystemPrompt(cwd) {
+    return [
+        'You are a coding agent running inside a local CLI.',
+        'Prefer using tools when they help answer precisely.',
+        'Do not invent file contents or command output when tools can verify them.',
+        'Before editing code, read the relevant files.',
+        'Explain briefly and act directly.',
+        `Current working directory: ${cwd}`,
+        'Available tools may read files, edit files, search files, and run shell commands.',
+    ].join('\n');
+}

package/dist/tools/editFile.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import type { ToolDefinition } from './types.js';
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+    oldText: z.ZodString;
+    newText: z.ZodString;
+}, z.core.$strip>;
+export declare const editFileTool: ToolDefinition<z.infer<typeof inputSchema>>;
+export {};

package/dist/tools/editFile.js

@@ -0,0 +1,48 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { isAbsolute, resolve } from 'node:path';
+import { z } from 'zod';
+const inputSchema = z.object({
+    path: z.string().min(1),
+    oldText: z.string(),
+    newText: z.string(),
+});
+function resolvePath(cwd, filePath) {
+    return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
+}
+export const editFileTool = {
+    name: 'edit_file',
+    description: 'Replace the first occurrence of oldText with newText in a text file.',
+    inputSchema,
+    inputSchemaJson: {
+        type: 'object',
+        properties: {
+            path: { type: 'string' },
+            oldText: { type: 'string' },
+            newText: { type: 'string' },
+        },
+        required: ['path', 'oldText', 'newText'],
+        additionalProperties: false,
+    },
+    isReadOnly: false,
+    async execute(input, context) {
+        if (context.approvalMode === 'manual') {
+            return {
+                isError: true,
+                content: 'edit_file is blocked in manual approval mode. Switch config approvalMode to auto to enable file edits.',
+            };
+        }
+        const absolutePath = resolvePath(context.cwd, input.path);
+        const current = await readFile(absolutePath, 'utf8');
+        if (!current.includes(input.oldText)) {
+            return {
+                isError: true,
+                content: 'oldText was not found in the target file.',
+            };
+        }
+        const next = current.replace(input.oldText, input.newText);
+        await writeFile(absolutePath, next, 'utf8');
+        return {
+            content: `Updated ${input.path}`,
+        };
+    },
+};

package/dist/tools/execute.d.ts

@@ -0,0 +1,3 @@
+import type { ToolUseBlock } from '../core/message.js';
+import type { ToolContext, ToolDefinition, ToolExecutionResult } from './types.js';
+export declare function executeToolCall(toolUse: ToolUseBlock, tools: ToolDefinition[], context: ToolContext): Promise<ToolExecutionResult>;

package/dist/tools/execute.js

@@ -0,0 +1,17 @@
+export async function executeToolCall(toolUse, tools, context) {
+    const tool = tools.find(item => item.name === toolUse.name);
+    if (!tool) {
+        return {
+            isError: true,
+            content: `Unknown tool: ${toolUse.name}`,
+        };
+    }
+    const parsed = tool.inputSchema.safeParse(toolUse.input);
+    if (!parsed.success) {
+        return {
+            isError: true,
+            content: parsed.error.message,
+        };
+    }
+    return tool.execute(parsed.data, context);
+}

package/dist/tools/grep.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import type { ToolDefinition } from './types.js';
+declare const inputSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    isRegex: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const grepTool: ToolDefinition<z.infer<typeof inputSchema>>;
+export {};

package/dist/tools/grep.js

@@ -0,0 +1,85 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { extname, isAbsolute, join, resolve } from 'node:path';
+import { z } from 'zod';
+const inputSchema = z.object({
+    pattern: z.string().min(1),
+    path: z.string().optional(),
+    maxResults: z.number().int().positive().max(200).optional(),
+    isRegex: z.boolean().optional(),
+});
+const textExtensions = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt', '.yml', '.yaml', '.css', '.html', '.mjs', '.cjs', '.sh', '.py', '.java', '.go', '.rs'
+]);
+async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist') {
+            continue;
+        }
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await walk(fullPath)));
+        }
+        else {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+export const grepTool = {
+    name: 'grep',
+    description: 'Search text files under the workspace for a pattern.',
+    inputSchema,
+    inputSchemaJson: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string' },
+            path: { type: 'string' },
+            maxResults: { type: 'integer' },
+            isRegex: { type: 'boolean' },
+        },
+        required: ['pattern'],
+        additionalProperties: false,
+    },
+    isReadOnly: true,
+    async execute(input, context) {
+        const root = input.path
+            ? isAbsolute(input.path)
+                ? input.path
+                : resolve(context.cwd, input.path)
+            : context.cwd;
+        const matcher = input.isRegex
+            ? new RegExp(input.pattern, 'i')
+            : null;
+        const files = await walk(root);
+        const results = [];
+        const maxResults = input.maxResults ?? 50;
+        for (const filePath of files) {
+            if (!textExtensions.has(extname(filePath))) {
+                continue;
+            }
+            const contents = await readFile(filePath, 'utf8').catch(() => '');
+            if (!contents) {
+                continue;
+            }
+            const lines = contents.split(/\r?\n/);
+            for (let index = 0; index < lines.length; index += 1) {
+                const line = lines[index] ?? '';
+                const matched = matcher
+                    ? matcher.test(line)
+                    : line.toLowerCase().includes(input.pattern.toLowerCase());
+                if (!matched) {
+                    continue;
+                }
+                results.push(`${filePath}:${index + 1}: ${line}`);
+                if (results.length >= maxResults) {
+                    return { content: results.join('\n') };
+                }
+            }
+        }
+        return {
+            content: results.length > 0 ? results.join('\n') : 'No matches found.',
+        };
+    },
+};

package/dist/tools/readFile.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import type { ToolDefinition } from './types.js';
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+    startLine: z.ZodOptional<z.ZodNumber>;
+    endLine: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const readFileTool: ToolDefinition<z.infer<typeof inputSchema>>;
+export {};

package/dist/tools/readFile.js

@@ -0,0 +1,41 @@
+import { readFile } from 'node:fs/promises';
+import { isAbsolute, resolve } from 'node:path';
+import { z } from 'zod';
+const inputSchema = z.object({
+    path: z.string().min(1),
+    startLine: z.number().int().positive().optional(),
+    endLine: z.number().int().positive().optional(),
+});
+function resolvePath(cwd, filePath) {
+    return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
+}
+export const readFileTool = {
+    name: 'read_file',
+    description: 'Read a text file from the workspace, optionally by line range.',
+    inputSchema,
+    inputSchemaJson: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Relative or absolute file path.' },
+            startLine: { type: 'integer', description: '1-based inclusive start line.' },
+            endLine: { type: 'integer', description: '1-based inclusive end line.' },
+        },
+        required: ['path'],
+        additionalProperties: false,
+    },
+    isReadOnly: true,
+    async execute(input, context) {
+        const absolutePath = resolvePath(context.cwd, input.path);
+        const contents = await readFile(absolutePath, 'utf8');
+        const lines = contents.split(/\r?\n/);
+        const start = Math.max((input.startLine ?? 1) - 1, 0);
+        const end = Math.min(input.endLine ?? lines.length, lines.length);
+        const slice = lines.slice(start, end);
+        const numbered = slice
+            .map((line, index) => `${start + index + 1}: ${line}`)
+            .join('\n');
+        return {
+            content: numbered || '(empty file)',
+        };
+    },
+};

package/dist/tools/registry.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDefinition } from './types.js';
+export declare function getDefaultTools(): ToolDefinition[];

package/dist/tools/registry.js

@@ -0,0 +1,7 @@
+import { editFileTool } from './editFile.js';
+import { grepTool } from './grep.js';
+import { readFileTool } from './readFile.js';
+import { runShellTool } from './runShell.js';
+export function getDefaultTools() {
+    return [readFileTool, editFileTool, grepTool, runShellTool];
+}

package/dist/tools/runShell.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import type { ToolDefinition } from './types.js';
+declare const inputSchema: z.ZodObject<{
+    command: z.ZodString;
+}, z.core.$strip>;
+export declare const runShellTool: ToolDefinition<z.infer<typeof inputSchema>>;
+export {};

package/dist/tools/runShell.js

@@ -0,0 +1,50 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+const execAsync = promisify(exec);
+const inputSchema = z.object({
+    command: z.string().min(1),
+});
+export const runShellTool = {
+    name: 'run_shell',
+    description: 'Run a shell command in the current working directory.',
+    inputSchema,
+    inputSchemaJson: {
+        type: 'object',
+        properties: {
+            command: {
+                type: 'string',
+                description: 'Shell command to run.',
+            },
+        },
+        required: ['command'],
+        additionalProperties: false,
+    },
+    isReadOnly: false,
+    async execute(input, context) {
+        if (context.approvalMode === 'manual') {
+            return {
+                isError: true,
+                content: 'run_shell is blocked in manual approval mode. Switch config approvalMode to auto to enable shell execution.',
+            };
+        }
+        try {
+            const { stdout, stderr } = await execAsync(input.command, {
+                cwd: context.cwd,
+                shell: '/bin/sh',
+                maxBuffer: 1024 * 1024,
+            });
+            const output = [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');
+            return {
+                content: output || '(command produced no output)',
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                isError: true,
+                content: message,
+            };
+        }
+    },
+};

package/dist/tools/types.d.ts

@@ -0,0 +1,32 @@
+import type { z } from 'zod';
+export type ToolExecutionResult = {
+    content: string;
+    isError?: boolean;
+};
+export type ToolContext = {
+    cwd: string;
+    approvalMode: 'auto' | 'manual';
+};
+export type AnthropicToolDefinition = {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+};
+export type OpenAICompatibleToolDefinition = {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+};
+export type ToolDefinition<TInput = unknown> = {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<TInput>;
+    inputSchemaJson: Record<string, unknown>;
+    isReadOnly: boolean;
+    execute(input: TInput, context: ToolContext): Promise<ToolExecutionResult>;
+};
+export declare function toAnthropicTool(tool: ToolDefinition): AnthropicToolDefinition;
+export declare function toOpenAICompatibleTool(tool: ToolDefinition): OpenAICompatibleToolDefinition;

package/dist/tools/types.js

@@ -0,0 +1,17 @@
+export function toAnthropicTool(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.inputSchemaJson,
+    };
+}
+export function toOpenAICompatibleTool(tool) {
+    return {
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.inputSchemaJson,
+        },
+    };
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "lcagent-cli",
+  "version": "0.1.0",
+  "description": "A minimal coding agent CLI for terminal-based coding workflows.",
+  "type": "module",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "preferGlobal": true,
+  "bin": {
+    "lcagent": "dist/bin/cli.js"
+  },
+  "scripts": {
+    "dev": "tsx src/bin/cli.ts",
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "start": "node dist/bin/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "agent",
+    "cli",
+    "coding-agent",
+    "terminal"
+  ],
+  "dependencies": {
+    "commander": "^14.0.0",
+    "zod": "^4.1.5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.3"
+  },
+  "license": "UNLICENSED"
+}