@archon-claw/cli 0.0.2

package/dist/test-runner.js

@@ -0,0 +1,166 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+async function loadImpl(implPath) {
+    const mod = await import(pathToFileURL(implPath).href);
+    return mod.default;
+}
+async function loadTestCases(testPath) {
+    const mod = await import(pathToFileURL(testPath).href);
+    return mod.default;
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (typeof a !== typeof b)
+        return false;
+    if (typeof a !== "object")
+        return false;
+    const aObj = a;
+    const bObj = b;
+    const keys = new Set([...Object.keys(aObj), ...Object.keys(bObj)]);
+    for (const key of keys) {
+        if (!deepEqual(aObj[key], bObj[key]))
+            return false;
+    }
+    return true;
+}
+async function runTestCase(impl, tc) {
+    try {
+        const actual = await impl(tc.args);
+        // Use validate() if provided
+        if (tc.validate) {
+            const verdict = tc.validate(actual);
+            if (verdict === true) {
+                return { name: tc.name, passed: true, actual };
+            }
+            const msg = typeof verdict === "string" ? verdict : "validate() returned false";
+            return { name: tc.name, passed: false, error: msg, actual };
+        }
+        // Use expected if provided
+        if (tc.expected !== undefined) {
+            if (deepEqual(actual, tc.expected)) {
+                return { name: tc.name, passed: true, actual };
+            }
+            return {
+                name: tc.name,
+                passed: false,
+                error: `expected ${JSON.stringify(tc.expected)}, got ${JSON.stringify(actual)}`,
+                actual,
+            };
+        }
+        // No assertion — just verify it doesn't throw
+        return { name: tc.name, passed: true, actual };
+    }
+    catch (err) {
+        return {
+            name: tc.name,
+            passed: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function runToolTests(agentDir) {
+    const absDir = path.resolve(agentDir);
+    const testsDir = path.join(absDir, "tests");
+    const implsDir = path.join(absDir, "tool-impls");
+    let files;
+    try {
+        files = await fs.readdir(testsDir);
+    }
+    catch {
+        return [];
+    }
+    const testFiles = files.filter((f) => f.endsWith(".test.js"));
+    if (testFiles.length === 0) {
+        return [];
+    }
+    const results = [];
+    for (const testFile of testFiles) {
+        const toolName = testFile.replace(/\.test\.js$/, "");
+        const implFile = path.join(implsDir, `${toolName}.impl.js`);
+        const testPath = path.join(testsDir, testFile);
+        // Check impl exists
+        try {
+            await fs.access(implFile);
+        }
+        catch {
+            results.push({
+                tool: toolName,
+                file: testFile,
+                results: [
+                    { name: "(load)", passed: false, error: `Missing implementation: ${toolName}.impl.js` },
+                ],
+            });
+            continue;
+        }
+        // Load impl and test cases
+        let impl;
+        let testCases;
+        try {
+            impl = await loadImpl(implFile);
+        }
+        catch (err) {
+            results.push({
+                tool: toolName,
+                file: testFile,
+                results: [
+                    {
+                        name: "(load)",
+                        passed: false,
+                        error: `Failed to load ${toolName}.impl.js: ${err instanceof Error ? err.message : err}`,
+                    },
+                ],
+            });
+            continue;
+        }
+        try {
+            testCases = await loadTestCases(testPath);
+        }
+        catch (err) {
+            results.push({
+                tool: toolName,
+                file: testFile,
+                results: [
+                    {
+                        name: "(load)",
+                        passed: false,
+                        error: `Failed to load ${testFile}: ${err instanceof Error ? err.message : err}`,
+                    },
+                ],
+            });
+            continue;
+        }
+        // Run each case
+        const caseResults = [];
+        for (const tc of testCases) {
+            caseResults.push(await runTestCase(impl, tc));
+        }
+        results.push({ tool: toolName, file: testFile, results: caseResults });
+    }
+    return results;
+}
+export function formatResults(results) {
+    const lines = [];
+    let totalPass = 0;
+    let totalFail = 0;
+    for (const tool of results) {
+        lines.push(`\n  ${tool.tool} (${tool.file})`);
+        for (const r of tool.results) {
+            if (r.passed) {
+                totalPass++;
+                lines.push(`    ✓ ${r.name}`);
+            }
+            else {
+                totalFail++;
+                lines.push(`    ✗ ${r.name}`);
+                lines.push(`      ${r.error}`);
+            }
+        }
+    }
+    lines.push("");
+    lines.push(`  ${totalPass + totalFail} tests, ${totalPass} passed, ${totalFail} failed`);
+    return lines.join("\n");
+}

package/dist/types.d.ts

@@ -0,0 +1,75 @@
+export type { JSONSchemaProperty, JSONSchema, ToolSchema, ModelConfig, } from "./schemas.js";
+/** Tool implementation function */
+export type ToolImplFn = (args: Record<string, unknown>) => Promise<unknown>;
+/** Loaded agent configuration */
+export interface AgentConfig {
+    systemPrompt: string;
+    model: import("./schemas.js").ModelConfig;
+    tools: import("./schemas.js").ToolSchema[];
+    toolImpls: Map<string, ToolImplFn>;
+    skills: Record<string, string>;
+    mcpManager?: import("./mcp-manager.js").McpManager;
+    agentDir: string;
+    toolUIs: Set<string>;
+}
+/** OpenAI-compatible chat message */
+export type ChatMessage = {
+    role: "system";
+    content: string;
+} | {
+    role: "user";
+    content: string;
+} | {
+    role: "assistant";
+    content: string | null;
+    tool_calls?: ToolCall[];
+} | {
+    role: "tool";
+    tool_call_id: string;
+    content: string;
+};
+/** Tool call from assistant response */
+export interface ToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** SSE event pushed to client */
+export type SSEEvent = {
+    type: "text";
+    content: string;
+} | {
+    type: "tool_call";
+    name: string;
+    args: Record<string, unknown>;
+    toolCallId: string;
+    executionTarget?: "client" | "host";
+} | {
+    type: "tool_result";
+    name: string;
+    result: unknown;
+    toolCallId: string;
+} | {
+    type: "tools_config";
+    tools: Array<{
+        name: string;
+        handler?: string;
+        executionTarget: string;
+        component?: string;
+    }>;
+} | {
+    type: "done";
+    sessionId: string;
+} | {
+    type: "error";
+    message: string;
+};
+/** Chat session state */
+export interface Session {
+    id: string;
+    messages: ChatMessage[];
+    createdAt: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/validator/index.d.ts

@@ -0,0 +1,16 @@
+import type { ValidatorPlugin, DirValidatorPlugin, ValidationResult } from "./plugin.js";
+export type { ValidatorPlugin, DirValidatorPlugin, ValidationResult } from "./plugin.js";
+/** Get a content validator plugin by name */
+export declare function getPlugin(name: string): ValidatorPlugin | undefined;
+/** Get all registered content plugins */
+export declare function getPlugins(): ValidatorPlugin[];
+/** Get a directory validator plugin by name */
+export declare function getDirPlugin(name: string): DirValidatorPlugin | undefined;
+/** Register a custom content plugin */
+export declare function registerPlugin(plugin: ValidatorPlugin): void;
+/** Register a custom directory plugin */
+export declare function registerDirPlugin(plugin: DirValidatorPlugin): void;
+/** Validate content using a specific plugin by name */
+export declare function validate(pluginName: string, content: string, fileName?: string): ValidationResult;
+/** Validate a directory using a specific dir plugin by name */
+export declare function validateDir(pluginName: string, dirPath: string): Promise<ValidationResult>;

package/dist/validator/index.js

@@ -0,0 +1,54 @@
+import { toolPlugin } from "./plugins/tool.js";
+import { modelPlugin } from "./plugins/model.js";
+import { systemPromptPlugin } from "./plugins/system-prompt.js";
+import { agentSkillPlugin } from "./plugins/agent-skill.js";
+import { datasetPlugin } from "./plugins/dataset.js";
+import { mcpPlugin } from "./plugins/mcp.js";
+import { agentDirPlugin } from "./plugins/agent-dir.js";
+const contentPlugins = [
+    toolPlugin,
+    modelPlugin,
+    systemPromptPlugin,
+    agentSkillPlugin,
+    datasetPlugin,
+    mcpPlugin,
+];
+const dirPlugins = [
+    agentDirPlugin,
+];
+/** Get a content validator plugin by name */
+export function getPlugin(name) {
+    return contentPlugins.find((p) => p.name === name);
+}
+/** Get all registered content plugins */
+export function getPlugins() {
+    return [...contentPlugins];
+}
+/** Get a directory validator plugin by name */
+export function getDirPlugin(name) {
+    return dirPlugins.find((p) => p.name === name);
+}
+/** Register a custom content plugin */
+export function registerPlugin(plugin) {
+    contentPlugins.push(plugin);
+}
+/** Register a custom directory plugin */
+export function registerDirPlugin(plugin) {
+    dirPlugins.push(plugin);
+}
+/** Validate content using a specific plugin by name */
+export function validate(pluginName, content, fileName) {
+    const plugin = getPlugin(pluginName);
+    if (!plugin) {
+        return { valid: false, errors: [`Unknown validator plugin: ${pluginName}`] };
+    }
+    return plugin.validate(content, fileName);
+}
+/** Validate a directory using a specific dir plugin by name */
+export async function validateDir(pluginName, dirPath) {
+    const plugin = getDirPlugin(pluginName);
+    if (!plugin) {
+        return { valid: false, errors: [`Unknown dir validator plugin: ${pluginName}`] };
+    }
+    return plugin.validate(dirPath);
+}

package/dist/validator/plugin.d.ts

@@ -0,0 +1,21 @@
+/** Validation result */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/** Content validator plugin - validates file content */
+export interface ValidatorPlugin {
+    /** Plugin name */
+    name: string;
+    /** File pattern this plugin handles, e.g. "*.json", "*.md" */
+    pattern: string;
+    /** Validate raw content, return result */
+    validate(content: string, fileName?: string): ValidationResult;
+}
+/** Directory validator plugin - validates directory structure */
+export interface DirValidatorPlugin {
+    /** Plugin name */
+    name: string;
+    /** Validate a directory path, return result */
+    validate(dirPath: string): Promise<ValidationResult>;
+}

package/dist/validator/plugin.js

@@ -0,0 +1 @@
+export {};

package/dist/validator/plugins/agent-dir.d.ts

@@ -0,0 +1,2 @@
+import type { DirValidatorPlugin } from "../plugin.js";
+export declare const agentDirPlugin: DirValidatorPlugin;

package/dist/validator/plugins/agent-dir.js

@@ -0,0 +1,171 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { modelPlugin } from "./model.js";
+import { systemPromptPlugin } from "./system-prompt.js";
+import { toolPlugin } from "./tool.js";
+import { agentSkillPlugin } from "./agent-skill.js";
+import { datasetPlugin } from "./dataset.js";
+import { mcpPlugin } from "./mcp.js";
+export const agentDirPlugin = {
+    name: "agent-dir",
+    async validate(dirPath) {
+        const errors = [];
+        // Check directory exists
+        try {
+            const stat = await fs.stat(dirPath);
+            if (!stat.isDirectory()) {
+                return { valid: false, errors: [`${dirPath} is not a directory`] };
+            }
+        }
+        catch {
+            return { valid: false, errors: [`${dirPath} does not exist`] };
+        }
+        // Check system-prompt.md
+        const promptPath = path.join(dirPath, "system-prompt.md");
+        try {
+            const content = await fs.readFile(promptPath, "utf-8");
+            const result = systemPromptPlugin.validate(content, "system-prompt.md");
+            if (!result.valid) {
+                errors.push(...result.errors.map((e) => `[system-prompt.md] ${e}`));
+            }
+        }
+        catch {
+            errors.push("Missing required file: system-prompt.md");
+        }
+        // Check model.json
+        const modelPath = path.join(dirPath, "model.json");
+        try {
+            const content = await fs.readFile(modelPath, "utf-8");
+            const result = modelPlugin.validate(content, "model.json");
+            if (!result.valid) {
+                errors.push(...result.errors.map((e) => `[model.json] ${e}`));
+            }
+        }
+        catch {
+            errors.push("Missing required file: model.json");
+        }
+        // Check tools/ directory
+        const toolsDir = path.join(dirPath, "tools");
+        try {
+            const stat = await fs.stat(toolsDir);
+            if (!stat.isDirectory()) {
+                errors.push("tools is not a directory");
+            }
+            else {
+                const files = await fs.readdir(toolsDir);
+                const jsonFiles = files.filter((f) => f.endsWith(".json"));
+                if (jsonFiles.length === 0) {
+                    errors.push("[tools/] No tool definitions found");
+                }
+                const toolNames = [];
+                const nonServerToolNames = new Set();
+                for (const file of jsonFiles) {
+                    const content = await fs.readFile(path.join(toolsDir, file), "utf-8");
+                    const result = toolPlugin.validate(content, file);
+                    if (!result.valid) {
+                        errors.push(...result.errors.map((e) => `[tools/${file}] ${e}`));
+                    }
+                    else {
+                        const name = file.replace(/\.json$/, "");
+                        toolNames.push(name);
+                        // Check if tool has execution_target that doesn't need server impl
+                        try {
+                            const parsed = JSON.parse(content);
+                            if (parsed.execution_target === "client" || parsed.execution_target === "host") {
+                                nonServerToolNames.add(name);
+                            }
+                        }
+                        catch { /* already validated above */ }
+                    }
+                }
+                // Server tools that need impl files
+                const serverToolNames = toolNames.filter((n) => !nonServerToolNames.has(n));
+                // Check tool-impls/ matches server tools
+                const implsDir = path.join(dirPath, "tool-impls");
+                try {
+                    const implStat = await fs.stat(implsDir);
+                    if (implStat.isDirectory()) {
+                        const implFiles = await fs.readdir(implsDir);
+                        const implNames = implFiles
+                            .filter((f) => f.endsWith(".impl.js"))
+                            .map((f) => f.replace(/\.impl\.js$/, ""));
+                        // server tools without impl
+                        for (const name of serverToolNames) {
+                            if (!implNames.includes(name)) {
+                                errors.push(`[tool-impls/] Missing implementation for tool: ${name}`);
+                            }
+                        }
+                        // impls without tool
+                        for (const name of implNames) {
+                            if (!toolNames.includes(name)) {
+                                errors.push(`[tool-impls/${name}.impl.js] No matching tool schema in tools/`);
+                            }
+                        }
+                    }
+                    else {
+                        errors.push("tool-impls is not a directory");
+                    }
+                }
+                catch {
+                    if (serverToolNames.length > 0) {
+                        errors.push("Missing required directory: tool-impls/");
+                    }
+                }
+            }
+        }
+        catch {
+            errors.push("Missing required directory: tools/");
+        }
+        // Check datasets/ directory (optional)
+        const datasetsDir = path.join(dirPath, "datasets");
+        try {
+            const stat = await fs.stat(datasetsDir);
+            if (stat.isDirectory()) {
+                const files = await fs.readdir(datasetsDir);
+                const jsonFiles = files.filter((f) => f.endsWith(".json"));
+                for (const file of jsonFiles) {
+                    const content = await fs.readFile(path.join(datasetsDir, file), "utf-8");
+                    const result = datasetPlugin.validate(content, file);
+                    if (!result.valid) {
+                        errors.push(...result.errors.map((e) => `[datasets/${file}] ${e}`));
+                    }
+                }
+            }
+        }
+        catch {
+            // datasets/ is optional, skip if not exists
+        }
+        // Check skills/ directory (optional)
+        const skillsDir = path.join(dirPath, "skills");
+        try {
+            const stat = await fs.stat(skillsDir);
+            if (stat.isDirectory()) {
+                const files = await fs.readdir(skillsDir);
+                const mdFiles = files.filter((f) => f.endsWith(".md"));
+                for (const file of mdFiles) {
+                    const content = await fs.readFile(path.join(skillsDir, file), "utf-8");
+                    const result = agentSkillPlugin.validate(content, file);
+                    if (!result.valid) {
+                        errors.push(...result.errors.map((e) => `[skills/${file}] ${e}`));
+                    }
+                }
+            }
+        }
+        catch {
+            // skills/ is optional, skip if not exists
+        }
+        // Check mcp.json (optional)
+        const mcpPath = path.join(dirPath, "mcp.json");
+        try {
+            const content = await fs.readFile(mcpPath, "utf-8");
+            const result = mcpPlugin.validate(content, "mcp.json");
+            if (!result.valid) {
+                errors.push(...result.errors.map((e) => `[mcp.json] ${e}`));
+            }
+        }
+        catch {
+            // mcp.json is optional, skip if not exists
+        }
+        return { valid: errors.length === 0, errors };
+    },
+};

package/dist/validator/plugins/agent-skill.d.ts

@@ -0,0 +1,2 @@
+import type { ValidatorPlugin } from "../plugin.js";
+export declare const agentSkillPlugin: ValidatorPlugin;

package/dist/validator/plugins/agent-skill.js

@@ -0,0 +1,31 @@
+import matter from "gray-matter";
+import { agentSkillFrontmatterSchema } from "../../schemas.js";
+import { formatZodErrors } from "../zod-utils.js";
+export const agentSkillPlugin = {
+    name: "agent-skill",
+    pattern: "skills/*.md",
+    validate(content, _fileName) {
+        const errors = [];
+        let parsed;
+        try {
+            parsed = matter(content);
+        }
+        catch {
+            return { valid: false, errors: ["Invalid frontmatter syntax"] };
+        }
+        if (!parsed.data || Object.keys(parsed.data).length === 0) {
+            errors.push("Missing frontmatter (---) block");
+        }
+        else {
+            const result = agentSkillFrontmatterSchema.safeParse(parsed.data);
+            if (!result.success) {
+                const schemaErrors = formatZodErrors(result.error).map((e) => `frontmatter${e}`);
+                errors.push(...schemaErrors);
+            }
+        }
+        if (!parsed.content.trim()) {
+            errors.push("Skill body content is empty");
+        }
+        return { valid: errors.length === 0, errors };
+    },
+};

package/dist/validator/plugins/dataset.d.ts

@@ -0,0 +1,2 @@
+import type { ValidatorPlugin } from "../plugin.js";
+export declare const datasetPlugin: ValidatorPlugin;

package/dist/validator/plugins/dataset.js

@@ -0,0 +1,20 @@
+import { datasetSchema } from "../../schemas.js";
+import { formatZodErrors } from "../zod-utils.js";
+export const datasetPlugin = {
+    name: "dataset",
+    pattern: "datasets/*.json",
+    validate(content, _fileName) {
+        let data;
+        try {
+            data = JSON.parse(content);
+        }
+        catch {
+            return { valid: false, errors: ["Invalid JSON"] };
+        }
+        const result = datasetSchema.safeParse(data);
+        if (!result.success) {
+            return { valid: false, errors: formatZodErrors(result.error) };
+        }
+        return { valid: true, errors: [] };
+    },
+};

package/dist/validator/plugins/mcp.d.ts

@@ -0,0 +1,2 @@
+import type { ValidatorPlugin } from "../plugin.js";
+export declare const mcpPlugin: ValidatorPlugin;

package/dist/validator/plugins/mcp.js

@@ -0,0 +1,20 @@
+import { mcpConfigSchema } from "../../schemas.js";
+import { formatZodErrors } from "../zod-utils.js";
+export const mcpPlugin = {
+    name: "mcp",
+    pattern: "mcp.json",
+    validate(content, _fileName) {
+        let data;
+        try {
+            data = JSON.parse(content);
+        }
+        catch {
+            return { valid: false, errors: ["Invalid JSON"] };
+        }
+        const result = mcpConfigSchema.safeParse(data);
+        if (!result.success) {
+            return { valid: false, errors: formatZodErrors(result.error) };
+        }
+        return { valid: true, errors: [] };
+    },
+};

package/dist/validator/plugins/model.d.ts

@@ -0,0 +1,2 @@
+import type { ValidatorPlugin } from "../plugin.js";
+export declare const modelPlugin: ValidatorPlugin;

package/dist/validator/plugins/model.js

@@ -0,0 +1,20 @@
+import { modelConfigSchema } from "../../schemas.js";
+import { formatZodErrors } from "../zod-utils.js";
+export const modelPlugin = {
+    name: "model",
+    pattern: "model.json",
+    validate(content, _fileName) {
+        let data;
+        try {
+            data = JSON.parse(content);
+        }
+        catch {
+            return { valid: false, errors: ["Invalid JSON"] };
+        }
+        const result = modelConfigSchema.safeParse(data);
+        if (!result.success) {
+            return { valid: false, errors: formatZodErrors(result.error) };
+        }
+        return { valid: true, errors: [] };
+    },
+};

package/dist/validator/plugins/system-prompt.d.ts

@@ -0,0 +1,2 @@
+import type { ValidatorPlugin } from "../plugin.js";
+export declare const systemPromptPlugin: ValidatorPlugin;

package/dist/validator/plugins/system-prompt.js

@@ -0,0 +1,25 @@
+import { Liquid } from "liquidjs";
+const liquid = new Liquid({ strictVariables: false, strictFilters: true });
+export const systemPromptPlugin = {
+    name: "system-prompt",
+    pattern: "system-prompt.md",
+    validate(content, _fileName) {
+        const errors = [];
+        if (!content.trim()) {
+            errors.push("System prompt content is empty");
+            return { valid: false, errors };
+        }
+        // Validate Liquid template syntax if template tags are present
+        const hasLiquid = /\{[%{]/.test(content);
+        if (hasLiquid) {
+            try {
+                liquid.parse(content);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                errors.push(`Liquid template syntax error: ${msg}`);
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    },
+};

package/dist/validator/plugins/tool.d.ts

@@ -0,0 +1,2 @@
+import type { ValidatorPlugin } from "../plugin.js";
+export declare const toolPlugin: ValidatorPlugin;