@alejandroroman/agent-kit 0.1.0

package/dist/cli/start.js

@@ -0,0 +1,235 @@
+import * as readline from "readline";
+import * as path from "path";
+import { loadConfig } from "../config/index.js";
+import { runAgentLoop } from "../agent/loop.js";
+import { compactMessages } from "../session/compaction.js";
+import { CronScheduler } from "../cron/scheduler.js";
+import { HeartbeatRunner } from "../heartbeat/index.js";
+import { createSlackGateway } from "../gateways/slack/index.js";
+import { createApiServer } from "../api/router.js";
+import { createLogger } from "../logger.js";
+import { buildAgentRuntime, buildSystemPrompt, initUsageStore, createAgentExecutor, } from "../bootstrap.js";
+import { ensureOllama } from "./ollama.js";
+import { resolveApiKey } from "./ui.js";
+const log = createLogger("start");
+const CONFIG_PATH = path.join(process.cwd(), "agent-kit.json");
+const DATA_DIR = path.join(process.cwd(), "data");
+const SKILLS_DIR = path.join(process.cwd(), "skills");
+const DEFAULT_AGENT = "default";
+export async function start() {
+    await resolveApiKey({ save: false });
+    const config = loadConfig(CONFIG_PATH);
+    // Ollama check (warn only)
+    if (config.defaults.memory) {
+        const ollama = await ensureOllama();
+        if (!ollama.running) {
+            log.warn("Ollama not running — memory tools unavailable");
+        }
+    }
+    const { usageStore, apiPort } = initUsageStore(config);
+    const apiServer = createApiServer({
+        config,
+        configPath: CONFIG_PATH,
+        usageStore,
+        dataDir: DATA_DIR,
+    }, apiPort);
+    // Build primary agent runtime (for REPL)
+    const agentName = process.argv[3] ?? DEFAULT_AGENT;
+    if (!config.agents[agentName]) {
+        const names = Object.keys(config.agents).join(", ");
+        console.error(`Agent "${agentName}" not found. Available: ${names}`);
+        process.exit(1);
+    }
+    const runtime = buildAgentRuntime(agentName, config, {
+        dataDir: DATA_DIR,
+        skillsDir: SKILLS_DIR,
+        usageStore,
+    });
+    runtime.toolRegistry.validateAgents(config.agents);
+    const { resolved, toolRegistry, agentRegistry, promptFragments, skillsIndex, soul, session } = runtime;
+    // Cron scheduler
+    const scheduler = new CronScheduler(config, toolRegistry, agentRegistry, DATA_DIR, SKILLS_DIR, usageStore);
+    const enabledJobs = scheduler.getJobs().filter((j) => j.enabled);
+    // Agent executor for Slack
+    const executeAgent = createAgentExecutor(config, {
+        dataDir: DATA_DIR,
+        skillsDir: SKILLS_DIR,
+        agentRegistry,
+        usageStore,
+        source: "slack",
+    });
+    // Slack gateway
+    let gateway;
+    const hasSlackBindings = Object.values(config.agents).some((a) => a.slack);
+    if (hasSlackBindings && process.env.SLACK_BOT_TOKEN && process.env.SLACK_APP_TOKEN) {
+        try {
+            gateway = createSlackGateway(config, { onAgentRequest: executeAgent });
+            await gateway.start();
+            const bindingCount = Object.values(config.agents).filter((a) => a.slack).length;
+            log.info({ bindings: bindingCount }, "Slack connected");
+        }
+        catch (err) {
+            log.warn({ err }, "Slack failed to connect");
+        }
+    }
+    // API server
+    try {
+        const actualPort = await apiServer.start();
+        log.info({ port: actualPort }, "API server started");
+    }
+    catch (err) {
+        log.warn({ err }, "failed to start API server");
+    }
+    // Cron
+    if (enabledJobs.length > 0) {
+        scheduler.start({
+            onResult: (jobId, agentName, result) => {
+                log.info({ jobId, tokens: result.usage.inputTokens + result.usage.outputTokens }, "cron job completed");
+                process.stdout.write("You: ");
+                const channelOverride = config.cron.find((j) => j.id === jobId)?.slack?.channelId;
+                gateway?.onJobResult(agentName, jobId, result, channelOverride).catch((err) => log.warn({ err, jobId }, "failed to post cron result to Slack"));
+            },
+            onError: (jobId, agentName, error) => {
+                log.error({ err: error, jobId }, "cron job failed");
+                process.stdout.write("You: ");
+                const channelOverride = config.cron.find((j) => j.id === jobId)?.slack?.channelId;
+                gateway?.onJobError(agentName, jobId, error, channelOverride).catch((err) => log.warn({ err, jobId }, "failed to post cron error to Slack"));
+            },
+        });
+    }
+    // Heartbeat
+    const heartbeat = new HeartbeatRunner(config, agentRegistry, DATA_DIR, SKILLS_DIR, usageStore);
+    const heartbeatAgents = heartbeat.getHeartbeatAgents();
+    if (heartbeatAgents.length > 0) {
+        heartbeat.start({
+            onResult: (agentName, result) => {
+                log.info({ agent: agentName, tokens: result.usage.inputTokens + result.usage.outputTokens }, "heartbeat alert");
+                process.stdout.write("You: ");
+                const channelOverride = config.agents[agentName]?.heartbeat?.slack?.channelId;
+                gateway?.onJobResult(agentName, "heartbeat", result, channelOverride).catch((err) => log.warn({ err, agent: agentName }, "failed to post heartbeat result to Slack"));
+            },
+            onError: (agentName, error) => {
+                log.error({ err: error, agent: agentName }, "heartbeat failed");
+                process.stdout.write("You: ");
+                const channelOverride = config.agents[agentName]?.heartbeat?.slack?.channelId;
+                gateway?.onJobError(agentName, "heartbeat", error, channelOverride).catch((err) => log.warn({ err, agent: agentName }, "failed to post heartbeat error to Slack"));
+            },
+            onSuppressed: (agentName) => {
+                log.debug({ agent: agentName }, "heartbeat OK, suppressed");
+            },
+        });
+    }
+    // Status dashboard
+    const agentList = Object.entries(config.agents);
+    console.log();
+    console.log("  Agent Kit");
+    console.log();
+    console.log(`  Agents: ${agentList.length}`);
+    for (const [name, def] of agentList) {
+        const emoji = def.emoji ?? " ";
+        const display = def.displayName ?? name;
+        console.log(`    ${emoji}  ${display} (${name})`);
+    }
+    console.log();
+    console.log(`  REPL agent: ${agentName} (${resolved.model})`);
+    if (enabledJobs.length > 0) {
+        console.log(`  Cron: ${enabledJobs.length} job(s)`);
+    }
+    if (heartbeatAgents.length > 0) {
+        console.log(`  Heartbeat: ${heartbeatAgents.join(", ")}`);
+    }
+    if (gateway) {
+        const bindingCount = Object.values(config.agents).filter((a) => a.slack).length;
+        console.log(`  Slack: ${bindingCount} binding(s)`);
+    }
+    if (config.defaults.usage) {
+        console.log(`  Usage: tracking enabled`);
+    }
+    console.log();
+    console.log(`  Commands: /new (reset), /agents, /help, /quit`);
+    console.log();
+    // REPL
+    let messages = session.getMessages();
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const shutdown = async () => {
+        scheduler.stop();
+        heartbeat.stop();
+        await gateway?.stop();
+        await apiServer.stop();
+        try {
+            usageStore?.close();
+        }
+        catch { }
+        rl.close();
+    };
+    const ask = () => {
+        rl.question("You: ", async (input) => {
+            const trimmed = input.trim();
+            if (trimmed === "/quit") {
+                await shutdown();
+                return;
+            }
+            if (trimmed === "/new") {
+                messages = [];
+                console.log("  Session reset.\n");
+                ask();
+                return;
+            }
+            if (trimmed === "/agents") {
+                for (const [name, def] of agentList) {
+                    const emoji = def.emoji ?? " ";
+                    const display = def.displayName ?? name;
+                    console.log(`  ${emoji}  ${display} (${name})`);
+                }
+                console.log();
+                ask();
+                return;
+            }
+            if (trimmed === "/help") {
+                console.log("  /new     — Reset conversation");
+                console.log("  /agents  — List agents");
+                console.log("  /quit    — Shut down\n");
+                ask();
+                return;
+            }
+            if (!trimmed) {
+                ask();
+                return;
+            }
+            const userMsg = { role: "user", content: trimmed };
+            messages.push(userMsg);
+            session.append(userMsg);
+            messages = await compactMessages(messages, resolved.model, resolved.compactionThreshold);
+            try {
+                const systemPrompt = buildSystemPrompt(soul, skillsIndex, promptFragments);
+                const result = await runAgentLoop(messages, {
+                    model: resolved.model,
+                    fallbacks: resolved.fallbacks,
+                    systemPrompt,
+                    toolRegistry,
+                    maxIterations: resolved.maxIterations,
+                    compactionThreshold: resolved.compactionThreshold,
+                    maxToolResultSize: resolved.maxToolResultSize,
+                    agentName,
+                    usageStore,
+                    source: "cli",
+                });
+                const newMessages = result.messages.slice(messages.length - 1);
+                for (const msg of newMessages) {
+                    session.append(msg);
+                }
+                messages = result.messages;
+                console.log(`\nAgent: ${result.text}`);
+                console.log(`  (${result.usage.inputTokens + result.usage.outputTokens} tokens)\n`);
+            }
+            catch (err) {
+                console.error(`\n  Error: ${err instanceof Error ? err.message : err}\n`);
+            }
+            ask();
+        });
+    };
+    ask();
+}

package/dist/cli/ui.d.ts

@@ -0,0 +1,17 @@
+export declare function banner(): void;
+export declare function status(label: string, value: string): void;
+export declare function done(message: string): void;
+export declare function onCancel(): void;
+/**
+ * Check if a @clack/prompts value was cancelled. Exits the process if so.
+ * The `return` after `isCancel()` in callers is technically unreachable
+ * but satisfies TypeScript control flow analysis.
+ */
+export declare function isCancel(value: unknown): value is symbol;
+/**
+ * Resolve the Anthropic API key: env var → .env file → interactive prompt.
+ * Sets process.env.ANTHROPIC_API_KEY so downstream LLM providers pick it up.
+ */
+export declare function resolveApiKey(opts?: {
+    save?: boolean;
+}): Promise<string>;

package/dist/cli/ui.js

@@ -0,0 +1,79 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as p from "@clack/prompts";
+const VERSION = "0.1.0";
+export function banner() {
+    console.log();
+    p.intro(`agent-kit v${VERSION}`);
+}
+export function status(label, value) {
+    p.log.info(`${label}: ${value}`);
+}
+export function done(message) {
+    p.outro(message);
+}
+export function onCancel() {
+    p.cancel("Cancelled.");
+    process.exit(0);
+}
+/**
+ * Check if a @clack/prompts value was cancelled. Exits the process if so.
+ * The `return` after `isCancel()` in callers is technically unreachable
+ * but satisfies TypeScript control flow analysis.
+ */
+export function isCancel(value) {
+    if (p.isCancel(value)) {
+        onCancel(); // calls process.exit(0)
+    }
+    return false;
+}
+/**
+ * Resolve the Anthropic API key: env var → .env file → interactive prompt.
+ * Sets process.env.ANTHROPIC_API_KEY so downstream LLM providers pick it up.
+ */
+export async function resolveApiKey(opts) {
+    // 1. Check env var
+    if (process.env.ANTHROPIC_API_KEY) {
+        return process.env.ANTHROPIC_API_KEY;
+    }
+    // 2. Check .env file
+    const envPath = path.join(process.cwd(), ".env");
+    if (fs.existsSync(envPath)) {
+        const content = fs.readFileSync(envPath, "utf-8");
+        const match = content.match(/^ANTHROPIC_API_KEY=(.+)$/m);
+        if (match) {
+            const key = match[1].trim().replace(/^["']|["']$/g, "");
+            process.env.ANTHROPIC_API_KEY = key;
+            return key;
+        }
+    }
+    // 3. Interactive prompt
+    const key = await p.text({
+        message: "Enter your Anthropic API key:",
+        placeholder: "sk-ant-...",
+        validate: (val) => {
+            if (!val?.trim())
+                return "API key is required";
+            if (!val.startsWith("sk-ant-"))
+                return "Key should start with sk-ant-";
+        },
+    });
+    if (isCancel(key))
+        process.exit(0);
+    const apiKey = key.trim();
+    process.env.ANTHROPIC_API_KEY = apiKey;
+    // 4. Offer to save to .env
+    if (opts?.save !== false) {
+        const shouldSave = await p.confirm({
+            message: "Save API key to .env for future use?",
+        });
+        if (!isCancel(shouldSave) && shouldSave) {
+            const envContent = fs.existsSync(envPath)
+                ? fs.readFileSync(envPath, "utf-8") + "\n"
+                : "";
+            fs.writeFileSync(envPath, envContent + `ANTHROPIC_API_KEY=${apiKey}\n`);
+            p.log.success("Saved to .env");
+        }
+    }
+    return apiKey;
+}

package/dist/cli/validate.d.ts

@@ -0,0 +1 @@
+export declare function validate(agentName?: string): void;

package/dist/cli/validate.js

@@ -0,0 +1,47 @@
+import * as path from "path";
+import { loadConfig } from "../config/index.js";
+import { validateAgent } from "../scripts/validate-agent.js";
+const PASS = "\u2713";
+const FAIL = "\u2717";
+const CONFIG_PATH = path.join(process.cwd(), "agent-kit.json");
+const SKILLS_DIR = path.join(process.cwd(), "skills");
+const DATA_DIR = path.join(process.cwd(), "data");
+function printResult(result) {
+    for (const check of result.checks) {
+        const icon = check.passed ? PASS : FAIL;
+        console.log(`  ${icon} [${check.name}] ${check.message}`);
+    }
+}
+export function validate(agentName) {
+    let config;
+    try {
+        config = loadConfig(CONFIG_PATH);
+    }
+    catch (err) {
+        console.error(`${FAIL} Config failed to load: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    const opts = { skillsDir: SKILLS_DIR, dataDir: DATA_DIR };
+    // Validate all agents if no name given
+    const names = agentName ? [agentName] : Object.keys(config.agents);
+    if (names.length === 0) {
+        console.log("No agents configured.");
+        return;
+    }
+    let allPassed = true;
+    for (const name of names) {
+        console.log(`\n  Validating: ${name}`);
+        const result = validateAgent(name, config, opts);
+        printResult(result);
+        if (!result.success)
+            allPassed = false;
+    }
+    console.log();
+    if (allPassed) {
+        console.log(`  All checks passed.`);
+    }
+    else {
+        console.log(`  Some checks failed.`);
+        process.exit(1);
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare const command: string;
+declare const args: string[];
+declare function main(): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+"use strict";
+const command = process.argv[2];
+const args = process.argv.slice(3);
+async function main() {
+    switch (command) {
+        case "init": {
+            const { init } = await import("./cli/init.js");
+            await init();
+            break;
+        }
+        case "start": {
+            const { start } = await import("./cli/start.js");
+            await start();
+            break;
+        }
+        case "create": {
+            const { create } = await import("./cli/create.js");
+            await create();
+            break;
+        }
+        case "list": {
+            const { list } = await import("./cli/list.js");
+            list();
+            break;
+        }
+        case "chat": {
+            const { chat } = await import("./cli/chat.js");
+            await chat(args[0]);
+            break;
+        }
+        case "validate": {
+            const { validate } = await import("./cli/validate.js");
+            validate(args[0]);
+            break;
+        }
+        default: {
+            console.log(`
+  agent-kit — personal AI agent framework
+
+  Usage:
+    agent-kit init              AI-powered setup wizard
+    agent-kit start             Start all services + REPL
+    agent-kit create            AI-powered agent creation
+    agent-kit list              Show configured agents
+    agent-kit chat <agent>      Lightweight single-agent chat
+    agent-kit validate [agent]  Validate config
+
+  Options:
+    --help                      Show this help
+      `);
+            process.exit(command === "--help" || command === "-h" ? 0 : 1);
+        }
+    }
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+export { ConfigSchema, type Config, type AgentDef, type CronJobDef, type SandboxDef, type ModelEntry, type SpawnTarget } from "./schema.js";
+export { loadConfig } from "./loader.js";
+export { resolveAgent, resolveModelAlias, buildFallbacks, type ResolvedAgent } from "./resolve.js";
+export { type SkillManifest } from "../skills/index.js";

package/dist/config/index.js

@@ -0,0 +1,3 @@
+export { ConfigSchema } from "./schema.js";
+export { loadConfig } from "./loader.js";
+export { resolveAgent, resolveModelAlias, buildFallbacks } from "./resolve.js";

package/dist/config/loader.d.ts

@@ -0,0 +1,2 @@
+import { type Config } from "./schema.js";
+export declare function loadConfig(configPath: string): Config;

package/dist/config/loader.js

@@ -0,0 +1,10 @@
+import * as fs from "fs";
+import { ConfigSchema } from "./schema.js";
+export function loadConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        return ConfigSchema.parse({});
+    }
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const json = JSON.parse(raw);
+    return ConfigSchema.parse(json);
+}

package/dist/config/resolve.d.ts

@@ -0,0 +1,22 @@
+import type { Config, SandboxDef, ModelEntry, SpawnTarget, WebSearchConfig } from "./schema.js";
+import type { ToolRegistry } from "../tools/registry.js";
+import type { Tool } from "../tools/types.js";
+import { type SkillManifest } from "../skills/index.js";
+export interface ResolvedAgent {
+    model: string;
+    fallbacks: string[];
+    tools: Tool[];
+    skills: SkillManifest[];
+    canSpawn: SpawnTarget[];
+    maxIterations: number;
+    maxTokens: number;
+    compactionThreshold: number;
+    commandTimeout: number;
+    maxToolResultSize: number;
+    spawn_only: boolean;
+    sandbox?: SandboxDef;
+}
+export declare function resolveWebSearch(agentName: string, config: Config): WebSearchConfig;
+export declare function resolveModelAlias(alias: string, models?: ModelEntry[]): string;
+export declare function buildFallbacks(primaryModel: string, models?: ModelEntry[]): string[];
+export declare function resolveAgent(name: string, config: Config, toolRegistry: ToolRegistry, skillsDir?: string): ResolvedAgent;

package/dist/config/resolve.js

@@ -0,0 +1,45 @@
+import { loadAllSkillManifests } from "../skills/index.js";
+export function resolveWebSearch(agentName, config) {
+    const agentDef = config.agents[agentName];
+    return agentDef?.webSearch ?? config.defaults.webSearch;
+}
+export function resolveModelAlias(alias, models) {
+    if (!models)
+        return alias;
+    const entry = models.find((m) => m.alias === alias);
+    if (!entry)
+        throw new Error(`Unknown model alias "${alias}"`);
+    return entry.model;
+}
+export function buildFallbacks(primaryModel, models) {
+    if (!models)
+        return [];
+    return models
+        .map((m) => m.model)
+        .filter((m) => m !== primaryModel);
+}
+export function resolveAgent(name, config, toolRegistry, skillsDir) {
+    const agentDef = config.agents[name];
+    if (!agentDef)
+        throw new Error(`Unknown agent "${name}"`);
+    const modelAlias = agentDef.model ?? config.defaults.model;
+    const model = resolveModelAlias(modelAlias, config.models);
+    const fallbacks = buildFallbacks(model, config.models);
+    const skills = agentDef.skills && agentDef.skills.length > 0 && skillsDir
+        ? loadAllSkillManifests(agentDef.skills, skillsDir)
+        : [];
+    return {
+        model,
+        fallbacks,
+        tools: toolRegistry.resolve(agentDef.tools),
+        skills,
+        canSpawn: agentDef.can_spawn,
+        maxIterations: agentDef.maxIterations ?? config.defaults.maxIterations,
+        maxTokens: agentDef.maxTokens ?? config.defaults.maxTokens,
+        compactionThreshold: config.defaults.compactionThreshold,
+        commandTimeout: config.defaults.commandTimeout,
+        maxToolResultSize: config.defaults.maxToolResultSize,
+        spawn_only: agentDef.spawn_only,
+        sandbox: agentDef.sandbox ?? config.defaults.sandbox,
+    };
+}