@archon-claw/cli 0.0.4 → 0.2.0

package/dist/session.js

@@ -1,82 +1,86 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
-let sessionsDir = "";
-const sessionCache = new Map();
-export async function initSessionStore(agentDir) {
-    sessionsDir = path.join(agentDir, "sessions");
-    sessionCache.clear();
-    await fs.mkdir(sessionsDir, { recursive: true });
-}
-function sessionPath(id) {
-    return path.join(sessionsDir, `${id}.json`);
-}
-export async function saveSession(session) {
-    session.updatedAt = Date.now();
-    sessionCache.set(session.id, session);
-    await fs.writeFile(sessionPath(session.id), JSON.stringify(session, null, 2));
-}
-export async function createSession() {
-    const now = Date.now();
-    const session = {
-        id: crypto.randomUUID(),
-        messages: [],
-        createdAt: now,
-        updatedAt: now,
-    };
-    await saveSession(session);
-    return session;
-}
-export async function getSession(id) {
-    const cached = sessionCache.get(id);
-    if (cached)
-        return cached;
-    try {
-        const data = await fs.readFile(sessionPath(id), "utf-8");
-        const session = JSON.parse(data);
-        sessionCache.set(id, session);
-        return session;
+export class SessionStore {
+    dir;
+    cache = new Map();
+    constructor(agentDir) {
+        this.dir = path.join(agentDir, "sessions");
     }
-    catch {
-        return undefined;
+    async init() {
+        this.cache.clear();
+        await fs.mkdir(this.dir, { recursive: true });
     }
-}
-export async function getOrCreateSession(id) {
-    if (id) {
-        const existing = await getSession(id);
-        if (existing)
-            return existing;
+    filePath(id) {
+        return path.join(this.dir, `${id}.json`);
     }
-    return createSession();
-}
-export async function deleteSession(id) {
-    sessionCache.delete(id);
-    try {
-        await fs.unlink(sessionPath(id));
-        return true;
+    async save(session) {
+        session.updatedAt = Date.now();
+        this.cache.set(session.id, session);
+        await fs.writeFile(this.filePath(session.id), JSON.stringify(session, null, 2));
     }
-    catch {
-        return false;
+    async create() {
+        const now = Date.now();
+        const session = {
+            id: crypto.randomUUID(),
+            messages: [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.save(session);
+        return session;
     }
-}
-export async function listSessions() {
-    try {
-        const files = await fs.readdir(sessionsDir);
-        const sessions = [];
-        for (const file of files) {
-            if (!file.endsWith(".json"))
-                continue;
-            try {
-                const data = await fs.readFile(path.join(sessionsDir, file), "utf-8");
-                sessions.push(JSON.parse(data));
-            }
-            catch {
-                // skip corrupt files
-            }
+    async get(id) {
+        const cached = this.cache.get(id);
+        if (cached)
+            return cached;
+        try {
+            const data = await fs.readFile(this.filePath(id), "utf-8");
+            const session = JSON.parse(data);
+            this.cache.set(id, session);
+            return session;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getOrCreate(id) {
+        if (id) {
+            const existing = await this.get(id);
+            if (existing)
+                return existing;
+        }
+        return this.create();
+    }
+    async delete(id) {
+        this.cache.delete(id);
+        try {
+            await fs.unlink(this.filePath(id));
+            return true;
+        }
+        catch {
+            return false;
         }
-        return sessions;
     }
-    catch {
-        return [];
+    async list() {
+        try {
+            const files = await fs.readdir(this.dir);
+            const sessions = [];
+            for (const file of files) {
+                if (!file.endsWith(".json"))
+                    continue;
+                try {
+                    const data = await fs.readFile(path.join(this.dir, file), "utf-8");
+                    sessions.push(JSON.parse(data));
+                }
+                catch {
+                    // skip corrupt files
+                }
+            }
+            return sessions;
+        }
+        catch {
+            return [];
+        }
     }
 }

package/dist/templates/workspace/README.md

@@ -0,0 +1,13 @@
+# {{name}}
+
+Built with [archon-claw](https://github.com/anthropics/archon-claw).
+
+## Getting Started
+
+```bash
+# Start dev server
+npm run dev
+
+# Start production server
+npm run start
+```

package/dist/templates/workspace/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "{{name}}",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "scripts": {
+    "dev": "archon-claw dev agents/my-agent",
+    "start": "archon-claw start agents/my-agent -p ${PORT:-5100}",
+    "create:agent": "archon-claw create-agent",
+    "update:skills": "archon-claw update-skills"
+  },
+  "keywords": [],
+  "license": "ISC",
+  "dependencies": {
+    "@archon-claw/cli": "^{{cliVersion}}"
+  }
+}

package/dist/validator/index.d.ts

@@ -1,5 +1,5 @@
 import type { ValidatorPlugin, DirValidatorPlugin, ValidationResult } from "./plugin.js";
-export type { ValidatorPlugin, DirValidatorPlugin, ValidationResult } from "./plugin.js";
+export type { ValidatorPlugin, DirValidatorPlugin, ValidationResult, ValidationError } from "./plugin.js";
 /** Get a content validator plugin by name */
 export declare function getPlugin(name: string): ValidatorPlugin | undefined;
 /** Get all registered content plugins */
@@ -8,6 +8,8 @@ export declare function getPlugins(): ValidatorPlugin[];
 export declare function getDirPlugin(name: string): DirValidatorPlugin | undefined;
 /** Register a custom content plugin */
 export declare function registerPlugin(plugin: ValidatorPlugin): void;
+/** Unregister a content plugin by name */
+export declare function unregisterPlugin(name: string): boolean;
 /** Register a custom directory plugin */
 export declare function registerDirPlugin(plugin: DirValidatorPlugin): void;
 /** Validate content using a specific plugin by name */

package/dist/validator/index.js

@@ -32,6 +32,14 @@ export function getDirPlugin(name) {
 export function registerPlugin(plugin) {
     contentPlugins.push(plugin);
 }
+/** Unregister a content plugin by name */
+export function unregisterPlugin(name) {
+    const idx = contentPlugins.findIndex((p) => p.name === name);
+    if (idx === -1)
+        return false;
+    contentPlugins.splice(idx, 1);
+    return true;
+}
 /** Register a custom directory plugin */
 export function registerDirPlugin(plugin) {
     dirPlugins.push(plugin);
@@ -40,7 +48,7 @@ export function registerDirPlugin(plugin) {
 export function validate(pluginName, content, fileName) {
     const plugin = getPlugin(pluginName);
     if (!plugin) {
-        return { valid: false, errors: [`Unknown validator plugin: ${pluginName}`] };
+        return { valid: false, errors: [{ message: `Unknown validator plugin: ${pluginName}`, severity: "error" }] };
     }
     return plugin.validate(content, fileName);
 }
@@ -48,7 +56,7 @@ export function validate(pluginName, content, fileName) {
 export async function validateDir(pluginName, dirPath) {
     const plugin = getDirPlugin(pluginName);
     if (!plugin) {
-        return { valid: false, errors: [`Unknown dir validator plugin: ${pluginName}`] };
+        return { valid: false, errors: [{ message: `Unknown dir validator plugin: ${pluginName}`, severity: "error" }] };
     }
     return plugin.validate(dirPath);
 }

package/dist/validator/plugin.d.ts

@@ -1,7 +1,17 @@
+/** Structured validation error */
+export interface ValidationError {
+    message: string;
+    severity: "error" | "warning";
+    file?: string;
+    path?: string;
+    expected?: string;
+    received?: string;
+    line?: number;
+}
 /** Validation result */
 export interface ValidationResult {
     valid: boolean;
-    errors: string[];
+    errors: ValidationError[];
 }
 /** Content validator plugin - validates file content */
 export interface ValidatorPlugin {
@@ -9,6 +19,8 @@ export interface ValidatorPlugin {
     name: string;
     /** File pattern this plugin handles, e.g. "*.json", "*.md" */
     pattern: string;
+    /** Whether this plugin's file(s) are required in an agent directory */
+    required?: boolean;
     /** Validate raw content, return result */
     validate(content: string, fileName?: string): ValidationResult;
 }

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

@@ -1,170 +1,154 @@
 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
+import picomatch from "picomatch";
+import { getPlugins } from "../index.js";
+/**
+ * Given a pattern like "model.json" or "tools/*.json", find matching files
+ * in the agent directory. Returns relative paths (e.g. "tools/t.json").
+ */
+async function matchFiles(dirPath, pattern) {
+    const parts = pattern.split("/");
+    if (parts.length === 1) {
+        // Flat file pattern like "model.json" or "custom-config.json"
+        const matcher = picomatch(pattern);
         try {
-            const stat = await fs.stat(dirPath);
-            if (!stat.isDirectory()) {
-                return { valid: false, errors: [`${dirPath} is not a directory`] };
-            }
+            const entries = await fs.readdir(dirPath);
+            return entries.filter((f) => matcher(f));
         }
         catch {
-            return { valid: false, errors: [`${dirPath} does not exist`] };
+            return [];
         }
-        // Check system-prompt.md
-        const promptPath = path.join(dirPath, "system-prompt.md");
+    }
+    // Directory pattern like "tools/*.json" or "skills/*.md"
+    const subDir = parts.slice(0, -1).join("/");
+    const filePattern = parts[parts.length - 1];
+    const matcher = picomatch(filePattern);
+    const fullSubDir = path.join(dirPath, subDir);
+    try {
+        const stat = await fs.stat(fullSubDir);
+        if (!stat.isDirectory())
+            return [];
+        const entries = await fs.readdir(fullSubDir);
+        return entries.filter((f) => matcher(f)).map((f) => `${subDir}/${f}`);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Validate tools/ + tool-impls/ cross-matching.
+ * This is special logic that cannot be driven purely by pattern matching.
+ * Receives pre-read tool file contents to avoid reading/validating them again.
+ */
+async function validateToolImpls(dirPath, toolContents, errors) {
+    const toolNames = [];
+    const nonServerToolNames = new Set();
+    for (const [relPath, content] of toolContents) {
+        const name = path.basename(relPath, ".json");
+        toolNames.push(name);
         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}`));
+            const parsed = JSON.parse(content);
+            if (parsed.execution_target === "client" || parsed.execution_target === "host") {
+                nonServerToolNames.add(name);
             }
         }
-        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 { /* already validated in main loop */ }
+    }
+    const serverToolNames = toolNames.filter((n) => !nonServerToolNames.has(n));
+    // Check tool-impls/
+    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$/, ""));
+            for (const name of serverToolNames) {
+                if (!implNames.includes(name)) {
+                    errors.push({ message: `Missing implementation for tool: ${name}`, severity: "error", file: "tool-impls/" });
+                }
+            }
+            for (const name of implNames) {
+                if (!toolNames.includes(name)) {
+                    errors.push({ message: `No matching tool schema in tools/ for ${name}.impl.js`, severity: "warning", file: `tool-impls/${name}.impl.js` });
+                }
             }
         }
-        catch {
-            errors.push("Missing required file: model.json");
+        else {
+            errors.push({ message: "tool-impls is not a directory", severity: "error", file: "tool-impls" });
         }
-        // Check tools/ directory
-        const toolsDir = path.join(dirPath, "tools");
+    }
+    catch {
+        if (serverToolNames.length > 0) {
+            errors.push({ message: "Missing required directory: tool-impls/", severity: "error", file: "tool-impls/" });
+        }
+    }
+}
+export const agentDirPlugin = {
+    name: "agent-dir",
+    async validate(dirPath) {
+        const errors = [];
+        // Check directory exists
         try {
-            const stat = await fs.stat(toolsDir);
+            const stat = await fs.stat(dirPath);
             if (!stat.isDirectory()) {
-                errors.push("tools is not a directory");
+                return { valid: false, errors: [{ message: `${dirPath} is not a directory`, severity: "error", file: dirPath }] };
             }
-            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 */ }
-                    }
+        }
+        catch {
+            return { valid: false, errors: [{ message: `${dirPath} does not exist`, severity: "error", file: dirPath }] };
+        }
+        const plugins = getPlugins();
+        // Track valid tool file contents for cross-matching with tool-impls
+        const validToolContents = new Map();
+        for (const plugin of plugins) {
+            const files = await matchFiles(dirPath, plugin.pattern);
+            if (files.length === 0) {
+                if (plugin.required) {
+                    errors.push({
+                        message: `Missing required file: ${plugin.pattern}`,
+                        severity: "error",
+                        file: plugin.pattern,
+                    });
                 }
-                // 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}`);
-                            }
+                // Special case: tool plugin needs at least 1 tool file
+                if (plugin.name === "tool") {
+                    // Check if the tools/ directory exists at all
+                    const toolsDir = path.join(dirPath, "tools");
+                    try {
+                        const stat = await fs.stat(toolsDir);
+                        if (!stat.isDirectory()) {
+                            errors.push({ message: "tools is not a directory", severity: "error", file: "tools" });
                         }
-                        // 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({ message: "No tool definitions found", severity: "error", file: "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({ message: "Missing required directory: tools/", severity: "error", file: "tools/" });
                     }
                 }
+                continue;
             }
-        }
-        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}`));
-                    }
+            // Validate each matched file
+            for (const relPath of files) {
+                const absPath = path.join(dirPath, relPath);
+                const content = await fs.readFile(absPath, "utf-8");
+                const fileName = path.basename(relPath);
+                const result = plugin.validate(content, fileName);
+                if (!result.valid) {
+                    errors.push(...result.errors.map((e) => ({ ...e, file: relPath })));
                 }
-            }
-        }
-        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}`));
-                    }
+                else if (plugin.name === "tool") {
+                    // Track valid tool contents for impl cross-matching
+                    validToolContents.set(relPath, content);
                 }
             }
         }
-        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
+        // tools/ + tool-impls/ cross-matching (special logic)
+        if (validToolContents.size > 0) {
+            await validateToolImpls(dirPath, validToolContents, errors);
         }
         return { valid: errors.length === 0, errors };
     },

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

@@ -11,20 +11,24 @@ export const agentSkillPlugin = {
             parsed = matter(content);
         }
         catch {
-            return { valid: false, errors: ["Invalid frontmatter syntax"] };
+            return { valid: false, errors: [{ message: "Invalid frontmatter syntax", severity: "error" }] };
         }
         if (!parsed.data || Object.keys(parsed.data).length === 0) {
-            errors.push("Missing frontmatter (---) block");
+            errors.push({ message: "Missing frontmatter (---) block", severity: "error" });
         }
         else {
             const result = agentSkillFrontmatterSchema.safeParse(parsed.data);
             if (!result.success) {
-                const schemaErrors = formatZodErrors(result.error).map((e) => `frontmatter${e}`);
+                const schemaErrors = formatZodErrors(result.error, parsed.data).map((e) => ({
+                    ...e,
+                    message: `frontmatter${e.message}`,
+                    path: e.path ? `frontmatter${e.path}` : e.path,
+                }));
                 errors.push(...schemaErrors);
             }
         }
         if (!parsed.content.trim()) {
-            errors.push("Skill body content is empty");
+            errors.push({ message: "Skill body content is empty", severity: "error" });
         }
         return { valid: errors.length === 0, errors };
     },

package/dist/validator/plugins/dataset.js

@@ -9,11 +9,11 @@ export const datasetPlugin = {
             data = JSON.parse(content);
         }
         catch {
-            return { valid: false, errors: ["Invalid JSON"] };
+            return { valid: false, errors: [{ message: "Invalid JSON", severity: "error" }] };
         }
         const result = datasetSchema.safeParse(data);
         if (!result.success) {
-            return { valid: false, errors: formatZodErrors(result.error) };
+            return { valid: false, errors: formatZodErrors(result.error, data, content) };
         }
         return { valid: true, errors: [] };
     },

package/dist/validator/plugins/mcp.js

@@ -9,11 +9,11 @@ export const mcpPlugin = {
             data = JSON.parse(content);
         }
         catch {
-            return { valid: false, errors: ["Invalid JSON"] };
+            return { valid: false, errors: [{ message: "Invalid JSON", severity: "error" }] };
         }
         const result = mcpConfigSchema.safeParse(data);
         if (!result.success) {
-            return { valid: false, errors: formatZodErrors(result.error) };
+            return { valid: false, errors: formatZodErrors(result.error, data, content) };
         }
         return { valid: true, errors: [] };
     },

package/dist/validator/plugins/model.js

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