scalix 1.0.0 → 1.1.0

package/.env.example

@@ -0,0 +1,29 @@
+# Required — your Scalix API key
+SCALIX_API_KEY=sk-...
+
+# Optional — custom API base URL (defaults to Scalix cloud)
+# SCALIX_BASE_URL=https://api.scalix.world/v1
+
+# Optional — override the default model
+# SCALIX_MODEL=
+
+# Optional — permission mode: plan | default | auto | yolo
+# SCALIX_PERMISSION_MODE=default
+
+# Optional — speech-to-text model for voice input
+# SCALIX_STT_MODEL=
+
+# Optional — log level: debug | info | warn | error
+# LOG_LEVEL=info
+
+# Optional — shell override (defaults to $SHELL)
+# SCALIX_SHELL=/bin/zsh
+
+# Optional — web search API keys (enable web_search tool)
+# BRAVE_API_KEY=
+# TAVILY_API_KEY=
+
+# Optional — custom search endpoint overrides
+# BRAVE_SEARCH_URL=
+# TAVILY_SEARCH_URL=
+# DDG_SEARCH_URL=

package/README.md

@@ -2,7 +2,7 @@
 
 AI-powered coding agent for the terminal and VS Code — built by [Scalix World](https://scalix.world).
 
-![Version](https://img.shields.io/badge/version-3.1.0-blue)
+![Version](https://img.shields.io/badge/version-1.0.0-blue)
 ![Node](https://img.shields.io/badge/node-%3E%3D18-green)
 ![License](https://img.shields.io/badge/license-EULA-orange)
 

package/dist/agent-definitions.js

@@ -0,0 +1,100 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { USER_CONFIG_DIR, PROJECT_LOOKUP_DIRS } from './constants.js';
+const VALID_TOOL_LEVELS = new Set(['read-only', 'standard', 'all']);
+const BUILT_IN_TYPES = new Set(['general', 'explore', 'plan']);
+export function parseAgentDefinition(content, filename) {
+    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!frontmatterMatch)
+        return null;
+    const [, frontmatter, body] = frontmatterMatch;
+    const instructions = body.trim();
+    if (!instructions)
+        return null;
+    const fields = {};
+    for (const line of frontmatter.split('\n')) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const val = line.slice(colonIdx + 1).trim();
+        fields[key] = val;
+    }
+    const name = fields.name || path.basename(filename, path.extname(filename));
+    if (BUILT_IN_TYPES.has(name))
+        return null;
+    const description = fields.description || `Custom agent: ${name}`;
+    const tools = VALID_TOOL_LEVELS.has(fields.tools) ? fields.tools : 'standard';
+    const maxSteps = fields.maxSteps ? parseInt(fields.maxSteps, 10) : undefined;
+    const model = fields.model && fields.model !== '(optional override)' ? fields.model : undefined;
+    const allowSpawning = fields.allowSpawning === 'true' ? true : fields.allowSpawning === 'false' ? false : undefined;
+    return {
+        name,
+        description,
+        tools,
+        maxSteps: maxSteps && Number.isFinite(maxSteps) && maxSteps > 0 ? maxSteps : undefined,
+        model,
+        allowSpawning,
+        instructions,
+    };
+}
+async function loadDefinitionsFromDir(dir) {
+    const defs = new Map();
+    try {
+        const entries = await fs.readdir(dir);
+        for (const entry of entries) {
+            if (!entry.endsWith('.md'))
+                continue;
+            try {
+                const content = await fs.readFile(path.join(dir, entry), 'utf-8');
+                const def = parseAgentDefinition(content, entry);
+                if (def)
+                    defs.set(def.name, def);
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+    }
+    catch {
+        // directory doesn't exist — that's fine
+    }
+    return defs;
+}
+export async function loadAgentDefinitions(projectDir) {
+    const globalDir = path.join(os.homedir(), USER_CONFIG_DIR, 'agents');
+    const globalDefs = await loadDefinitionsFromDir(globalDir);
+    const projectDefs = new Map();
+    if (projectDir) {
+        for (const lookupDir of PROJECT_LOOKUP_DIRS) {
+            const dir = path.join(projectDir, lookupDir, 'agents');
+            const defs = await loadDefinitionsFromDir(dir);
+            for (const [name, def] of defs) {
+                projectDefs.set(name, def);
+            }
+        }
+    }
+    // Project definitions override global
+    const merged = new Map(globalDefs);
+    for (const [name, def] of projectDefs) {
+        merged.set(name, def);
+    }
+    return merged;
+}
+let _cachedDefinitions = null;
+let _cacheProjectDir;
+export async function getAgentDefinitions(projectDir) {
+    if (_cachedDefinitions && _cacheProjectDir === projectDir)
+        return _cachedDefinitions;
+    _cachedDefinitions = await loadAgentDefinitions(projectDir);
+    _cacheProjectDir = projectDir;
+    return _cachedDefinitions;
+}
+export function invalidateAgentDefinitionCache() {
+    _cachedDefinitions = null;
+    _cacheProjectDir = undefined;
+}
+export function isBuiltInAgentType(name) {
+    return BUILT_IN_TYPES.has(name);
+}

package/dist/agent-registry.js

@@ -0,0 +1,226 @@
+import { EventEmitter } from 'eventemitter3';
+import { randomUUID } from 'node:crypto';
+import { logger } from './logger.js';
+import { MULTI_AGENT_DEFAULTS } from './constants.js';
+export class AgentRegistry extends EventEmitter {
+    static instance = null;
+    agents = new Map();
+    agentRefs = new Map();
+    messages = [];
+    limits;
+    constructor(limits) {
+        super();
+        this.limits = {
+            maxDepth: limits?.maxDepth ?? MULTI_AGENT_DEFAULTS.maxDepth,
+            maxConcurrentAgents: limits?.maxConcurrentAgents ?? MULTI_AGENT_DEFAULTS.maxConcurrentAgents,
+            globalTokenBudget: limits?.globalTokenBudget ?? MULTI_AGENT_DEFAULTS.globalTokenBudget,
+        };
+    }
+    static getInstance(limits) {
+        if (!AgentRegistry.instance) {
+            AgentRegistry.instance = new AgentRegistry(limits);
+        }
+        return AgentRegistry.instance;
+    }
+    static resetInstance() {
+        if (AgentRegistry.instance) {
+            AgentRegistry.instance.removeAllListeners();
+            AgentRegistry.instance.agents.clear();
+            AgentRegistry.instance.agentRefs.clear();
+            AgentRegistry.instance.messages = [];
+        }
+        AgentRegistry.instance = null;
+    }
+    register(id, agentRef, parentId, metadata) {
+        const depth = parentId ? this.getDepth(parentId) + 1 : 0;
+        const entry = {
+            id,
+            parentId,
+            depth,
+            description: metadata.description,
+            model: metadata.model,
+            status: 'running',
+            tokenUsage: 0,
+            stepCount: 0,
+            spawnedAt: Date.now(),
+            completedAt: null,
+        };
+        this.agents.set(id, entry);
+        this.agentRefs.set(id, agentRef);
+        this.emit('agent:spawned', entry);
+        logger.info('Agent registered', { id, parentId, depth, description: metadata.description });
+    }
+    deregister(id, status) {
+        const entry = this.agents.get(id);
+        if (!entry)
+            return;
+        entry.status = status;
+        entry.completedAt = Date.now();
+        this.agentRefs.delete(id);
+        this.emit('agent:completed', entry);
+        logger.info('Agent deregistered', { id, status, tokens: entry.tokenUsage, steps: entry.stepCount });
+    }
+    getAgent(id) {
+        return this.agentRefs.get(id);
+    }
+    getMeta(id) {
+        return this.agents.get(id);
+    }
+    listActive() {
+        return [...this.agents.values()].filter(a => a.status === 'running');
+    }
+    listAll() {
+        return [...this.agents.values()];
+    }
+    getChildren(parentId) {
+        return [...this.agents.values()].filter(a => a.parentId === parentId);
+    }
+    getDepth(id) {
+        const entry = this.agents.get(id);
+        if (!entry)
+            return 0;
+        if (!entry.parentId)
+            return 0;
+        return 1 + this.getDepth(entry.parentId);
+    }
+    canSpawn(parentId) {
+        const activeCount = this.listActive().length;
+        if (activeCount >= this.limits.maxConcurrentAgents) {
+            return { allowed: false, reason: `Concurrent agent limit reached (${activeCount}/${this.limits.maxConcurrentAgents})` };
+        }
+        if (parentId) {
+            const depth = this.getDepth(parentId) + 1;
+            if (depth >= this.limits.maxDepth) {
+                return { allowed: false, reason: `Maximum agent depth reached (${depth}/${this.limits.maxDepth})` };
+            }
+        }
+        const totalTokens = this.getTotalTokens();
+        if (totalTokens >= this.limits.globalTokenBudget) {
+            return { allowed: false, reason: `Global token budget exhausted (${totalTokens.toLocaleString()}/${this.limits.globalTokenBudget.toLocaleString()})` };
+        }
+        return { allowed: true };
+    }
+    // --- Messaging ---
+    sendMessage(from, to, content) {
+        if (from === to) {
+            return { error: 'Cannot send a message to self' };
+        }
+        const recipient = this.agents.get(to);
+        if (!recipient) {
+            return { error: `Agent "${to}" not found` };
+        }
+        if (recipient.status !== 'running') {
+            return { error: `Agent "${to}" is not running (status: ${recipient.status})` };
+        }
+        const msg = {
+            id: randomUUID(),
+            from,
+            to,
+            content,
+            timestamp: Date.now(),
+            read: false,
+        };
+        this.messages.push(msg);
+        this.emit('agent:message', msg);
+        return msg;
+    }
+    broadcast(from, content) {
+        const sent = [];
+        for (const agent of this.listActive()) {
+            if (agent.id === from)
+                continue;
+            const result = this.sendMessage(from, agent.id, content);
+            if ('id' in result)
+                sent.push(result);
+        }
+        return sent;
+    }
+    getUnread(agentId) {
+        return this.messages.filter(m => m.to === agentId && !m.read);
+    }
+    markRead(agentId) {
+        for (const msg of this.messages) {
+            if (msg.to === agentId && !msg.read) {
+                msg.read = true;
+            }
+        }
+    }
+    // --- Resource Tracking ---
+    recordTokens(id, tokens) {
+        const entry = this.agents.get(id);
+        if (entry) {
+            entry.tokenUsage += tokens;
+        }
+        const totalTokens = this.getTotalTokens();
+        const budgetPct = totalTokens / this.limits.globalTokenBudget;
+        if (budgetPct >= 0.9) {
+            this.emit('budget:warning', {
+                totalTokens,
+                budget: this.limits.globalTokenBudget,
+                percentage: Math.round(budgetPct * 100),
+            });
+        }
+    }
+    recordStep(id) {
+        const entry = this.agents.get(id);
+        if (entry) {
+            entry.stepCount++;
+        }
+    }
+    getTotalTokens() {
+        let total = 0;
+        for (const entry of this.agents.values()) {
+            total += entry.tokenUsage;
+        }
+        return total;
+    }
+    getUsageSummary() {
+        const all = [...this.agents.values()];
+        return {
+            totalTokens: this.getTotalTokens(),
+            activeCount: all.filter(a => a.status === 'running').length,
+            completedCount: all.filter(a => a.status === 'completed').length,
+            failedCount: all.filter(a => a.status === 'failed' || a.status === 'aborted').length,
+            byAgent: all.map(a => ({
+                id: a.id,
+                description: a.description,
+                model: a.model,
+                tokens: a.tokenUsage,
+                steps: a.stepCount,
+                status: a.status,
+            })),
+        };
+    }
+    getAgentTree(rootId) {
+        const lines = [];
+        const roots = rootId
+            ? [this.agents.get(rootId)].filter(Boolean)
+            : [...this.agents.values()].filter(a => !a.parentId);
+        const render = (entry, indent) => {
+            const statusIcon = entry.status === 'running' ? '*' : entry.status === 'completed' ? '+' : 'x';
+            lines.push(`${indent}[${statusIcon}] ${entry.id.slice(0, 8)} ${entry.description} (${entry.model}, ${entry.tokenUsage.toLocaleString()} tok)`);
+            const children = this.getChildren(entry.id);
+            for (const child of children) {
+                render(child, indent + '  ');
+            }
+        };
+        for (const root of roots) {
+            render(root, '');
+        }
+        return lines.join('\n') || '(no agents)';
+    }
+    getLimits() {
+        return { ...this.limits };
+    }
+    setLimits(limits) {
+        if (limits.maxDepth !== undefined)
+            this.limits.maxDepth = limits.maxDepth;
+        if (limits.maxConcurrentAgents !== undefined)
+            this.limits.maxConcurrentAgents = limits.maxConcurrentAgents;
+        if (limits.globalTokenBudget !== undefined)
+            this.limits.globalTokenBudget = limits.globalTokenBudget;
+    }
+}
+export function generateAgentId() {
+    return randomUUID();
+}