zilmate 1.4.0 → 1.6.1

package/.env.example

@@ -24,6 +24,8 @@ ZILMATE_VOICE_INPUT_DEVICE=
 ZILMATE_SCREENSHOT_MODEL=google/gemini-3.1-flash-lite
 ZILMATE_CAMERA_DEVICE=
 ZILMATE_FILE_ROOTS=
+ZILMATE_WORKSPACE=
+ZILMATE_WEBHOOK_PORT=8787
 ZILO_MANAGER_MODEL=minimax/minimax-m3
 ZILO_HELP_MODEL=alibaba/qwen3.7-plus
 ZILO_POST_MODEL=alibaba/qwen3.7-plus

package/dist/agents/coding.agent.d.ts

@@ -0,0 +1,352 @@
+import { ToolLoopAgent } from 'ai';
+export declare function createCodingAgent(runId?: string): ToolLoopAgent<never, {
+    readScratchpad: import("ai").Tool<Record<string, never>, string>;
+    appendScratchpad: import("ai").Tool<{
+        note: string;
+    }, string>;
+    listSkills: import("ai").Tool<Record<string, never>, {
+        skills: import("../skills/loader.js").SkillSummary[];
+        searchPaths: string[];
+        registry: string;
+    }>;
+    searchSkills: import("ai").Tool<{
+        query: string;
+        limit?: number | undefined;
+    }, {
+        query: string;
+        skills: import("../skills/loader.js").SkillSummary[];
+        scope: string;
+    }>;
+    searchSkillsRegistry: import("ai").Tool<{
+        query: string;
+        limit?: number | undefined;
+    }, {
+        query: string;
+        results: import("../skills/registry.js").RegistrySkill[];
+        installHint: string;
+        browse: string;
+    }>;
+    installRegistrySkill: import("ai").Tool<{
+        packageRef: string;
+        global?: boolean | undefined;
+    }, {
+        ok: boolean;
+        packageRef: string;
+        installPath: string;
+        output: string;
+        browse: string;
+    }>;
+    readSkill: import("ai").Tool<{
+        skillId: string;
+    }, import("../skills/loader.js").SkillContent>;
+    executeCommand: import("ai").Tool<{
+        command: string;
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+        env?: Record<string, string> | undefined;
+    }, {
+        success: boolean;
+        exit: any;
+        stdout: any;
+        stderr: any;
+        command: string;
+    }>;
+    installDependencies: import("ai").Tool<{
+        command: string;
+        manager?: "npm" | "pnpm" | "yarn" | undefined;
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        success: boolean;
+        exit: any;
+        manager: string;
+        stdout: any;
+        stderr: any;
+    }>;
+    runPipeline: import("ai").Tool<{
+        commands: string[];
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        success: boolean;
+        exit: any;
+        stdout: any;
+        stderr: any;
+        pipeline: string;
+    }>;
+    pythonScript: import("ai").Tool<{
+        code: string;
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        success: boolean;
+        exit: any;
+        stdout: any;
+        stderr: any;
+    }>;
+    getSystemInfo: import("ai").Tool<Record<string, never>, {
+        platform: NodeJS.Platform;
+        arch: NodeJS.Architecture;
+        release: string;
+        cpuCores: number;
+        totalMemoryGB: string;
+        freeMemoryGB: string;
+        nodeVersion: string;
+        currentUser: string;
+        uptime: string;
+        homeDir: string;
+    } | {
+        platform: NodeJS.Platform;
+        arch: NodeJS.Architecture;
+        error: any;
+    }>;
+    listProcesses: import("ai").Tool<{
+        filter?: string | undefined;
+        limit?: number | undefined;
+    }, {
+        processes: string[];
+        count: number;
+        filtered: boolean;
+        error?: never;
+    } | {
+        error: any;
+        processes: never[];
+        count: number;
+        filtered?: never;
+    }>;
+    findInPath: import("ai").Tool<{
+        command: string;
+    }, {
+        found: boolean;
+        command: string;
+        path: string;
+        suggestion?: never;
+    } | {
+        found: boolean;
+        command: string;
+        suggestion: string;
+        path?: never;
+    }>;
+    searchFiles: import("ai").Tool<{
+        query: string;
+        root?: string | undefined;
+        includeContent?: boolean | undefined;
+        maxDepth?: number | undefined;
+        maxResults?: number | undefined;
+    }, {
+        match: string;
+        excerpt: string;
+        path: string;
+        absolutePath: string;
+        type: "file" | "directory";
+        size: number;
+        modifiedAt: string;
+    }[]>;
+    readFile: import("ai").Tool<{
+        path: string;
+        maxBytes?: number | undefined;
+    }, {
+        path: string;
+        size: number;
+        modifiedAt: string;
+        truncated: boolean;
+        content: string;
+    }>;
+    writeFile: import("ai").Tool<{
+        path: string;
+        content: string;
+        mode?: "append" | "overwrite" | undefined;
+    }, {
+        path: string;
+        bytes: number;
+        mode: "append" | "overwrite";
+    }>;
+    createFolder: import("ai").Tool<{
+        path: string;
+    }, {
+        path: string;
+        created: boolean;
+    }>;
+    moveCopyRename: import("ai").Tool<{
+        operation: "move" | "copy" | "rename";
+        from: string;
+        to: string;
+        overwrite?: boolean | undefined;
+    }, {
+        operation: "move" | "copy" | "rename";
+        from: string;
+        to: string;
+    }>;
+    summarizeDocument: import("ai").Tool<{
+        path: string;
+        maxBytes?: number | undefined;
+    }, {
+        characters: number;
+        words: number;
+        summary: string;
+        path: string;
+        truncated: boolean;
+    }>;
+    watchFolderChanges: import("ai").Tool<{
+        path?: string | undefined;
+        watchName?: string | undefined;
+        reset?: boolean | undefined;
+        maxDepth?: number | undefined;
+    }, {
+        watchName: string;
+        baselineSaved: boolean;
+        added: string[];
+        changed: string[];
+        removed: string[];
+    }>;
+    findDuplicateLargeFiles: import("ai").Tool<{
+        root?: string | undefined;
+        minSizeBytes?: number | undefined;
+        maxDepth?: number | undefined;
+        maxResults?: number | undefined;
+    }, {
+        large: {
+            path: string;
+            absolutePath: string;
+            type: "file" | "directory";
+            size: number;
+            modifiedAt: string;
+        }[];
+        duplicateSizeGroups: {
+            size: number;
+            files: string[];
+        }[];
+    }>;
+    deleteFile: import("ai").Tool<{
+        path: string;
+        confirm: boolean;
+    }, {
+        deleted: boolean;
+        path: string;
+        size: number;
+    }>;
+    deleteFolder: import("ai").Tool<{
+        path: string;
+        confirm: boolean;
+    }, {
+        deleted: boolean;
+        path: string;
+    }>;
+    listDirectory: import("ai").Tool<{
+        path: string;
+        filter?: string | undefined;
+        includeHidden?: boolean | undefined;
+        maxDepth?: number | undefined;
+        limit?: number | undefined;
+    }, {
+        directory: string;
+        entries: {
+            path: string;
+            absolutePath: string;
+            type: "file" | "directory";
+            size: number;
+            modifiedAt: string;
+        }[];
+        count: number;
+        filtered: boolean;
+    }>;
+    getFileInfo: import("ai").Tool<{
+        path: string;
+    }, {
+        path: string;
+        type: string;
+        size: number;
+        sizeKB: string;
+        sizeMB: string;
+        created: string;
+        modified: string;
+        accessed: string;
+        isFile: boolean;
+        isDirectory: boolean;
+        isSymlink: boolean;
+        mode: string;
+    }>;
+    gitStatus: import("ai").Tool<{
+        short: boolean;
+        cwd?: string | undefined;
+    }, {
+        cwd: string;
+        output: string;
+    }>;
+    gitDiff: import("ai").Tool<{
+        staged: boolean;
+        cwd?: string | undefined;
+        path?: string | undefined;
+        commit?: string | undefined;
+    }, {
+        cwd: string;
+        output: string;
+    }>;
+    gitLog: import("ai").Tool<{
+        limit: number;
+        cwd?: string | undefined;
+        path?: string | undefined;
+    }, {
+        cwd: string;
+        output: string;
+    }>;
+    gitBranch: import("ai").Tool<{
+        action: "list" | "create" | "checkout";
+        cwd?: string | undefined;
+        name?: string | undefined;
+    }, {
+        cwd: string;
+        branches: string;
+        action?: never;
+        name?: never;
+        output?: never;
+    } | {
+        cwd: string;
+        action: "create" | "checkout";
+        name: string;
+        output: string;
+        branches?: never;
+    }>;
+    gitStage: import("ai").Tool<{
+        paths: string[];
+        cwd?: string | undefined;
+    }, {
+        cwd: string;
+        staged: string[];
+        output: string;
+    }>;
+    gitCommit: import("ai").Tool<{
+        message: string;
+        cwd?: string | undefined;
+    }, {
+        cwd: string;
+        message: string;
+        output: string;
+    }>;
+    applyUnifiedPatch: import("ai").Tool<{
+        patch: string;
+        dryRun: boolean;
+        cwd?: string | undefined;
+    }, {
+        dryRun: boolean;
+        cwd: string;
+        check: string;
+        applied?: never;
+        output?: never;
+    } | {
+        cwd: string;
+        applied: boolean;
+        output: string;
+        dryRun?: never;
+        check?: never;
+    }>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
+}, never>;
+//# sourceMappingURL=coding.agent.d.ts.map

package/dist/agents/coding.agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding.agent.d.ts","sourceRoot":"","sources":["../../src/agents/coding.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAUhD,wBAAgB,iBAAiB,CAAC,KAAK,SAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwBlD"}

package/dist/agents/coding.agent.js

@@ -0,0 +1,34 @@
+import { stepCountIs, ToolLoopAgent } from 'ai';
+import { models } from '../config/models.js';
+import { createScratchpadTools } from '../tools/scratchpad.tool.js';
+import { fileSystemTools } from '../tools/filesystem.tool.js';
+import { gitTools } from '../tools/git.tool.js';
+import { shellTools } from '../tools/shell.tool.js';
+import { skillTools } from '../tools/skills.tool.js';
+import { timeTools } from '../tools/time.tool.js';
+import { limits } from '../safety/limits.js';
+export function createCodingAgent(runId = 'default') {
+    const scratchpadTools = createScratchpadTools(runId);
+    return new ToolLoopAgent({
+        model: models.coding,
+        instructions: [
+            'You are ZilMate Coding Agent — a focused software engineering partner for this machine.',
+            'Prefer small, reviewable changes: read files, use gitDiff, applyUnifiedPatch for surgical edits instead of rewriting entire files.',
+            'Workflow: gitStatus → read affected files → gitDiff → patch or targeted writeFile → run tests via executeCommand → gitStage → gitCommit (only when user asked to commit).',
+            'Use git tools for branch awareness, diffs, staging, and commits. Never force-push unless the user explicitly requests it.',
+            'Use searchSkills/readSkill when a repo skill documents conventions.',
+            'Report what you changed, which files, and test/build output. Keep scratchpad notes for multi-file refactors.',
+            'Do not claim tests passed unless executeCommand output shows success.',
+        ].join(' '),
+        tools: {
+            ...timeTools,
+            ...gitTools,
+            ...fileSystemTools,
+            ...shellTools,
+            ...skillTools,
+            ...scratchpadTools,
+        },
+        stopWhen: stepCountIs(limits.subagentSteps),
+    });
+}
+//# sourceMappingURL=coding.agent.js.map

package/dist/agents/coding.agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding.agent.js","sourceRoot":"","sources":["../../src/agents/coding.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,iBAAiB,CAAC,KAAK,GAAG,SAAS;IACjD,MAAM,eAAe,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAErD,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,MAAM;QACpB,YAAY,EAAE;YACZ,yFAAyF;YACzF,oIAAoI;YACpI,2KAA2K;YAC3K,2HAA2H;YAC3H,qEAAqE;YACrE,8GAA8G;YAC9G,uEAAuE;SACxE,CAAC,IAAI,CAAC,GAAG,CAAC;QACX,KAAK,EAAE;YACL,GAAG,SAAS;YACZ,GAAG,QAAQ;YACX,GAAG,eAAe;YAClB,GAAG,UAAU;YACb,GAAG,UAAU;YACb,GAAG,eAAe;SACnB;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}

package/dist/agents/goal-manager.agent.d.ts

@@ -0,0 +1,125 @@
+import { ToolLoopAgent } from 'ai';
+export declare function createGoalManagerAgent(): ToolLoopAgent<never, {
+    createJob: import("ai").Tool<{
+        task: string;
+        schedule?: string | undefined;
+        runAt?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, import("../server.js").ZilMateJob>;
+    listJobs: import("ai").Tool<{
+        status?: "running" | "failed" | "queued" | "succeeded" | "cancelled" | undefined;
+        limit?: number | undefined;
+    }, import("../server.js").ZilMateJob[]>;
+    showJob: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").ZilMateJob | null>;
+    listJobLogs: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").JobLog[]>;
+    cancelJob: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").ZilMateJob | null>;
+    getPersonalContext: import("ai").Tool<Record<string, never>, {
+        context: import("../memory/personal-context.js").PersonalContext;
+        summary: string;
+    }>;
+    updatePersonalContext: import("ai").Tool<{
+        ownerName?: string | undefined;
+        businessName?: string | undefined;
+        urgencyRule?: string | undefined;
+        workflow?: string | undefined;
+        contact?: {
+            name: string;
+            vip: boolean;
+            id?: string | undefined;
+            email?: string | undefined;
+            handle?: string | undefined;
+            role?: string | undefined;
+            notes?: string | undefined;
+        } | undefined;
+        project?: {
+            name: string;
+            status: "done" | "active" | "paused";
+            tags: string[];
+            id?: string | undefined;
+            description?: string | undefined;
+        } | undefined;
+    }, {
+        updated: boolean;
+        summary: string;
+    }>;
+    getKnowledgeGraph: import("ai").Tool<Record<string, never>, import("../memory/knowledge-graph.js").KnowledgeGraph>;
+    setKnowledgeOwner: import("ai").Tool<{
+        name: string;
+    }, import("../memory/knowledge-graph.js").KnowledgeGraph>;
+    upsertKnowledgeNode: import("ai").Tool<{
+        label: string;
+        type: "other" | "topic" | "project" | "tool" | "goal" | "person" | "org";
+        parentLabel?: string | undefined;
+        notes?: string | undefined;
+        tags?: string[] | undefined;
+    }, import("../memory/knowledge-graph.js").KnowledgeNode | {
+        parent: import("../memory/knowledge-graph.js").KnowledgeNode;
+        child: import("../memory/knowledge-graph.js").KnowledgeNode;
+    }>;
+    searchKnowledgeGraph: import("ai").Tool<{
+        query: string;
+        limit?: number | undefined;
+    }, import("../memory/knowledge-graph.js").KnowledgeNode[]>;
+    getKnowledgeTree: import("ai").Tool<{
+        rootLabel?: string | undefined;
+    }, Record<string, unknown>>;
+    readNotebook: import("ai").Tool<{
+        limitChars?: number | undefined;
+    }, {
+        paths: {
+            markdown: string;
+            json: string;
+        };
+        content: string;
+    }>;
+    appendNotebook: import("ai").Tool<{
+        title: string;
+        body: string;
+        tags?: string[] | undefined;
+    }, import("../memory/notebook.js").NotebookEntry>;
+    searchNotebook: import("ai").Tool<{
+        query: string;
+        limit?: number | undefined;
+    }, import("../memory/notebook.js").NotebookEntry[]>;
+    listNotebookEntries: import("ai").Tool<{
+        limit?: number | undefined;
+    }, import("../memory/notebook.js").NotebookEntry[]>;
+    quickNotebookNote: import("ai").Tool<{
+        section: string;
+        content: string;
+    }, {
+        path: string;
+        section: string;
+        appendedAt: string;
+    }>;
+    rememberMemory: import("ai").Tool<{
+        text: string;
+        tags?: string[] | undefined;
+    }, import("../server.js").LongTermMemory>;
+    recallMemory: import("ai").Tool<{
+        query?: string | undefined;
+        limit?: number | undefined;
+    }, import("../server.js").LongTermMemory[]>;
+    listMemory: import("ai").Tool<Record<string, never>, import("../server.js").LongTermMemory[]>;
+    forgetMemory: import("ai").Tool<{
+        id: string;
+    }, {
+        id: string;
+        deleted: boolean;
+    }>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
+}, never>;
+//# sourceMappingURL=goal-manager.agent.d.ts.map

package/dist/agents/goal-manager.agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"goal-manager.agent.d.ts","sourceRoot":"","sources":["../../src/agents/goal-manager.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAe,MAAM,IAAI,CAAC;AAUhD,wBAAgB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqBrC"}

package/dist/agents/goal-manager.agent.js

@@ -0,0 +1,32 @@
+import { ToolLoopAgent, stepCountIs } from 'ai';
+import { models } from '../config/models.js';
+import { limits } from '../safety/limits.js';
+import { memoryTools } from '../tools/memory.tool.js';
+import { timeTools } from '../tools/time.tool.js';
+import { notebookTools } from '../tools/notebook.tool.js';
+import { knowledgeTools } from '../tools/knowledge.tool.js';
+import { personalContextTools } from '../tools/personal-context.tool.js';
+import { jobTools } from '../tools/jobs.tool.js';
+export function createGoalManagerAgent() {
+    return new ToolLoopAgent({
+        model: models.manager,
+        instructions: [
+            'You are ZilMate Goal Manager — break goals into actionable steps with clear owners, deadlines, and dependencies.',
+            'Start by clarifying the goal outcome, constraints, and definition of done.',
+            'Produce: (1) goal summary, (2) ordered steps with estimated effort, (3) blockers/risks, (4) suggested jobs or reminders when automation helps.',
+            'Use getCurrentTime for any schedule wording. Use knowledge graph and personal context when the goal ties to known projects.',
+            'Use notebook tools to save the plan. Use job tools only when the user wants scheduled follow-ups.',
+            'Keep steps small enough to finish in one sitting when possible.',
+        ].join(' '),
+        tools: {
+            ...timeTools,
+            ...memoryTools,
+            ...notebookTools,
+            ...knowledgeTools,
+            ...personalContextTools,
+            ...jobTools,
+        },
+        stopWhen: stepCountIs(Math.min(limits.managerSteps, 12)),
+    });
+}
+//# sourceMappingURL=goal-manager.agent.js.map

package/dist/agents/goal-manager.agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"goal-manager.agent.js","sourceRoot":"","sources":["../../src/agents/goal-manager.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,MAAM,UAAU,sBAAsB;IACpC,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,OAAO;QACrB,YAAY,EAAE;YACZ,kHAAkH;YAClH,4EAA4E;YAC5E,gJAAgJ;YAChJ,6HAA6H;YAC7H,mGAAmG;YACnG,iEAAiE;SAClE,CAAC,IAAI,CAAC,GAAG,CAAC;QACX,KAAK,EAAE;YACL,GAAG,SAAS;YACZ,GAAG,WAAW;YACd,GAAG,aAAa;YAChB,GAAG,cAAc;YACjB,GAAG,oBAAoB;YACvB,GAAG,QAAQ;SACZ;QACD,QAAQ,EAAE,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;KACzD,CAAC,CAAC;AACL,CAAC"}