scalix 0.0.1 → 1.0.0

package/dist/settings.js

@@ -0,0 +1,155 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { DEFAULT_BASE_URL, DEFAULT_MODELS, AGENT_DEFAULTS, CONTEXT_DEFAULTS, WEB_DEFAULTS, TOOL_DEFAULTS, SUB_AGENT_DEFAULTS, USER_CONFIG_DIR, registerUserModels, } from './constants.js';
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', USER_CONFIG_DIR);
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+export const THINKING_MODES = ['off', 'low', 'medium', 'high'];
+export const DEFAULT_LIMITS = {
+    maxSteps: AGENT_DEFAULTS.maxSteps,
+    maxMessages: AGENT_DEFAULTS.maxMessages,
+    maxContextTokens: CONTEXT_DEFAULTS.maxContextTokens,
+    compressionThreshold: CONTEXT_DEFAULTS.compressionThreshold,
+    maxToolResultTokens: CONTEXT_DEFAULTS.maxToolResultTokens,
+    toolTimeoutMs: AGENT_DEFAULTS.toolTimeoutMs,
+    maxRetries: AGENT_DEFAULTS.maxRetries,
+    messageKeepRatio: AGENT_DEFAULTS.messageKeepRatio,
+    circuitBreakerThreshold: AGENT_DEFAULTS.circuitBreakerThreshold,
+    circuitBreakerResetMs: AGENT_DEFAULTS.circuitBreakerResetMs,
+    commandTimeoutMs: TOOL_DEFAULTS.commandTimeoutMs,
+    webFetchTimeoutMs: WEB_DEFAULTS.fetchTimeoutMs,
+    htmlMaxSize: WEB_DEFAULTS.htmlMaxSize,
+    defaultSearchResults: WEB_DEFAULTS.defaultSearchResults,
+    defaultMaxFetchLength: WEB_DEFAULTS.defaultMaxLength,
+    bgBufferMax: TOOL_DEFAULTS.bgBufferMax,
+    bgCleanupMs: TOOL_DEFAULTS.bgCleanupMs,
+    searchTimeoutMs: TOOL_DEFAULTS.searchTimeoutMs,
+    fileRefTruncation: TOOL_DEFAULTS.fileRefTruncation,
+    charsPerToken: CONTEXT_DEFAULTS.charsPerToken,
+    minRecentMessages: CONTEXT_DEFAULTS.minRecentMessages,
+    subAgentTimeoutMs: SUB_AGENT_DEFAULTS.timeoutMs,
+    subAgentMaxSteps: SUB_AGENT_DEFAULTS.maxSteps,
+    subAgentMaxContextTokens: SUB_AGENT_DEFAULTS.maxContextTokens,
+    subAgentCompressionThreshold: SUB_AGENT_DEFAULTS.compressionThreshold,
+    agentToolTimeoutMs: SUB_AGENT_DEFAULTS.agentToolTimeoutMs,
+    exploreMaxSteps: SUB_AGENT_DEFAULTS.exploreMaxSteps,
+    shellDetectionTimeoutMs: TOOL_DEFAULTS.shellDetectionTimeoutMs,
+    treeMaxEntries: TOOL_DEFAULTS.treeMaxEntries,
+    gitTimeoutMs: TOOL_DEFAULTS.gitTimeoutMs,
+    gitDiffMaxBuffer: TOOL_DEFAULTS.gitDiffMaxBuffer,
+    readFileMaxSize: TOOL_DEFAULTS.readFileMaxSize,
+    maxEditStringLength: TOOL_DEFAULTS.maxEditStringLength,
+    maxNotebookSource: TOOL_DEFAULTS.maxNotebookSource,
+    maxWebFetchLength: TOOL_DEFAULTS.maxWebFetchLength,
+    slidingWindowTarget: CONTEXT_DEFAULTS.slidingWindowTarget,
+};
+const DEFAULTS = {
+    apiKey: '',
+    baseUrl: DEFAULT_BASE_URL,
+    models: [...DEFAULT_MODELS],
+    customModels: {},
+    limits: { ...DEFAULT_LIMITS },
+    permissionMode: 'default',
+    thinkingMode: 'off',
+};
+function safeNumber(val, min, max, fallback) {
+    if (typeof val === 'number' && Number.isFinite(val) && val >= min && val <= max)
+        return val;
+    return fallback;
+}
+function validateConfig(parsed) {
+    const safe = {};
+    if (typeof parsed.apiKey === 'string')
+        safe.apiKey = parsed.apiKey;
+    if (typeof parsed.baseUrl === 'string' && parsed.baseUrl.length > 0)
+        safe.baseUrl = parsed.baseUrl;
+    if (Array.isArray(parsed.models) && parsed.models.every((m) => typeof m === 'string')) {
+        safe.models = parsed.models;
+    }
+    if (typeof parsed.permissionMode === 'string' && ['plan', 'default', 'auto', 'yolo'].includes(parsed.permissionMode)) {
+        safe.permissionMode = parsed.permissionMode;
+    }
+    if (parsed.customModels && typeof parsed.customModels === 'object' && !Array.isArray(parsed.customModels)) {
+        const validated = {};
+        for (const [id, spec] of Object.entries(parsed.customModels)) {
+            const s = spec;
+            if (typeof s === 'object' && s &&
+                typeof s.contextWindow === 'number' && s.contextWindow > 0 &&
+                typeof s.maxOutputTokens === 'number' && s.maxOutputTokens > 0) {
+                validated[id] = { contextWindow: s.contextWindow, maxOutputTokens: s.maxOutputTokens };
+            }
+        }
+        if (Object.keys(validated).length > 0) {
+            safe.customModels = validated;
+        }
+    }
+    if (parsed.limits && typeof parsed.limits === 'object' && !Array.isArray(parsed.limits)) {
+        const l = parsed.limits;
+        safe.limits = {
+            maxSteps: safeNumber(l.maxSteps, 1, Infinity, DEFAULT_LIMITS.maxSteps),
+            maxMessages: safeNumber(l.maxMessages, 1, Infinity, DEFAULT_LIMITS.maxMessages),
+            maxContextTokens: safeNumber(l.maxContextTokens, 1000, Infinity, DEFAULT_LIMITS.maxContextTokens),
+            compressionThreshold: safeNumber(l.compressionThreshold, 0.1, 0.99, DEFAULT_LIMITS.compressionThreshold),
+            maxToolResultTokens: safeNumber(l.maxToolResultTokens, 100, Infinity, DEFAULT_LIMITS.maxToolResultTokens),
+            toolTimeoutMs: safeNumber(l.toolTimeoutMs, 1000, 600_000, DEFAULT_LIMITS.toolTimeoutMs),
+            maxRetries: safeNumber(l.maxRetries, 0, 20, DEFAULT_LIMITS.maxRetries),
+            messageKeepRatio: safeNumber(l.messageKeepRatio, 0.1, 0.99, DEFAULT_LIMITS.messageKeepRatio),
+            circuitBreakerThreshold: safeNumber(l.circuitBreakerThreshold, 1, 50, DEFAULT_LIMITS.circuitBreakerThreshold),
+            circuitBreakerResetMs: safeNumber(l.circuitBreakerResetMs, 1000, 600_000, DEFAULT_LIMITS.circuitBreakerResetMs),
+            commandTimeoutMs: safeNumber(l.commandTimeoutMs, 1000, 600_000, DEFAULT_LIMITS.commandTimeoutMs),
+            webFetchTimeoutMs: safeNumber(l.webFetchTimeoutMs, 1000, 120_000, DEFAULT_LIMITS.webFetchTimeoutMs),
+            htmlMaxSize: safeNumber(l.htmlMaxSize, 1024, Infinity, DEFAULT_LIMITS.htmlMaxSize),
+            defaultSearchResults: safeNumber(l.defaultSearchResults, 1, 100, DEFAULT_LIMITS.defaultSearchResults),
+            defaultMaxFetchLength: safeNumber(l.defaultMaxFetchLength, 1000, Infinity, DEFAULT_LIMITS.defaultMaxFetchLength),
+            bgBufferMax: safeNumber(l.bgBufferMax, 1024, Infinity, DEFAULT_LIMITS.bgBufferMax),
+            bgCleanupMs: safeNumber(l.bgCleanupMs, 60_000, 86_400_000, DEFAULT_LIMITS.bgCleanupMs),
+            searchTimeoutMs: safeNumber(l.searchTimeoutMs, 1000, 600_000, DEFAULT_LIMITS.searchTimeoutMs),
+            fileRefTruncation: safeNumber(l.fileRefTruncation, 1000, Infinity, DEFAULT_LIMITS.fileRefTruncation),
+            charsPerToken: safeNumber(l.charsPerToken, 1, 10, DEFAULT_LIMITS.charsPerToken),
+            minRecentMessages: safeNumber(l.minRecentMessages, 1, 100, DEFAULT_LIMITS.minRecentMessages),
+            subAgentTimeoutMs: safeNumber(l.subAgentTimeoutMs, 5000, Infinity, DEFAULT_LIMITS.subAgentTimeoutMs),
+            subAgentMaxSteps: safeNumber(l.subAgentMaxSteps, 1, Infinity, DEFAULT_LIMITS.subAgentMaxSteps),
+            subAgentMaxContextTokens: safeNumber(l.subAgentMaxContextTokens, 1000, Infinity, DEFAULT_LIMITS.subAgentMaxContextTokens),
+            subAgentCompressionThreshold: safeNumber(l.subAgentCompressionThreshold, 0.1, 0.99, DEFAULT_LIMITS.subAgentCompressionThreshold),
+            agentToolTimeoutMs: safeNumber(l.agentToolTimeoutMs, 5000, Infinity, DEFAULT_LIMITS.agentToolTimeoutMs),
+            exploreMaxSteps: safeNumber(l.exploreMaxSteps, 1, Infinity, DEFAULT_LIMITS.exploreMaxSteps),
+            shellDetectionTimeoutMs: safeNumber(l.shellDetectionTimeoutMs, 500, 30_000, DEFAULT_LIMITS.shellDetectionTimeoutMs),
+            treeMaxEntries: safeNumber(l.treeMaxEntries, 10, Infinity, DEFAULT_LIMITS.treeMaxEntries),
+            gitTimeoutMs: safeNumber(l.gitTimeoutMs, 1000, 120_000, DEFAULT_LIMITS.gitTimeoutMs),
+            gitDiffMaxBuffer: safeNumber(l.gitDiffMaxBuffer, 1024, Infinity, DEFAULT_LIMITS.gitDiffMaxBuffer),
+            readFileMaxSize: safeNumber(l.readFileMaxSize, 1024, Infinity, DEFAULT_LIMITS.readFileMaxSize),
+            maxEditStringLength: safeNumber(l.maxEditStringLength, 1000, Infinity, DEFAULT_LIMITS.maxEditStringLength),
+            maxNotebookSource: safeNumber(l.maxNotebookSource, 1000, Infinity, DEFAULT_LIMITS.maxNotebookSource),
+            maxWebFetchLength: safeNumber(l.maxWebFetchLength, 1000, Infinity, DEFAULT_LIMITS.maxWebFetchLength),
+            slidingWindowTarget: safeNumber(l.slidingWindowTarget, 0.1, 0.99, DEFAULT_LIMITS.slidingWindowTarget),
+        };
+    }
+    if (typeof parsed.thinkingMode === 'string' && THINKING_MODES.includes(parsed.thinkingMode)) {
+        safe.thinkingMode = parsed.thinkingMode;
+    }
+    return safe;
+}
+async function ensureDir() {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+}
+export async function loadConfig() {
+    try {
+        const raw = await fs.readFile(CONFIG_FILE, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const validated = validateConfig(parsed);
+        const config = { ...DEFAULTS, ...validated };
+        if (config.customModels && Object.keys(config.customModels).length > 0) {
+            registerUserModels(config.customModels);
+        }
+        return config;
+    }
+    catch {
+        return { ...DEFAULTS };
+    }
+}
+export async function saveConfig(config) {
+    await ensureDir();
+    await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), { encoding: 'utf-8', mode: 0o600 });
+}
+export function isConfigured(config) {
+    return config.apiKey.length > 0 && config.models.length > 0;
+}

package/dist/sub-agent.js

@@ -0,0 +1,79 @@
+import { createAgent } from './agent.js';
+import { defaultTools } from './tools.js';
+import { extraTools } from './tools-extra.js';
+import { webTools } from './tools-web.js';
+import { advancedTools } from './tools-advanced.js';
+import { logger } from './logger.js';
+import { SUB_AGENT_DEFAULTS, CHEAP_MODEL_INDICATORS } from './constants.js';
+const READ_ONLY_TOOL_NAMES = new Set([
+    'get_current_time', 'calculate', 'read_file', 'read_file_lines',
+    'list_files', 'search_files', 'find_files', 'tree',
+    'git_status', 'git_diff', 'web_search', 'monitor',
+]);
+function selectTools(level) {
+    // Include advanced tools but exclude 'agent' to prevent recursive spawning
+    const all = [...defaultTools, ...extraTools, ...webTools, ...advancedTools]
+        .filter((t) => (t.function?.name || t.name) !== 'agent');
+    switch (level) {
+        case 'read-only':
+            return all.filter((t) => READ_ONLY_TOOL_NAMES.has(t.function?.name || t.name));
+        case 'all':
+            return all;
+        case 'standard':
+        default:
+            return all;
+    }
+}
+export async function spawnSubAgent(parentConfig, prompt, options = {}) {
+    const model = options.model || parentConfig.models[parentConfig.models.length - 1];
+    const tools = selectTools(options.tools);
+    const timeout = options.timeout ?? SUB_AGENT_DEFAULTS.timeoutMs;
+    const permissionMode = options.permissionMode
+        ?? (options.tools === 'read-only' ? 'plan' : options.tools === 'all' ? 'auto' : 'default');
+    const subAgent = createAgent({
+        apiKey: parentConfig.apiKey,
+        baseUrl: parentConfig.baseUrl,
+        model,
+        instructions: options.instructions || 'You are a focused research assistant. Be concise and factual. Respond in under 500 words.',
+        tools,
+        permissionMode,
+        confirmToolCall: options.confirmToolCall,
+        maxSteps: options.maxSteps ?? SUB_AGENT_DEFAULTS.maxSteps,
+        contextManager: {
+            maxContextTokens: SUB_AGENT_DEFAULTS.maxContextTokens,
+            compressionThreshold: SUB_AGENT_DEFAULTS.compressionThreshold,
+        },
+    });
+    let steps = 0;
+    let tokenEstimate = 0;
+    subAgent.on('tool:call', () => { steps++; });
+    subAgent.on('usage', (data) => {
+        tokenEstimate += data.total_tokens ?? 0;
+    });
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`Sub-agent timed out after ${timeout}ms`)), timeout);
+    });
+    try {
+        const response = await Promise.race([subAgent.send(prompt), timeoutPromise]);
+        logger.info('Sub-agent completed', { model, steps, tokens: tokenEstimate });
+        return { response, model, tokenEstimate, steps };
+    }
+    catch (err) {
+        subAgent.abort();
+        logger.error('Sub-agent failed', { model, error: err.message });
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function pickCheapestModel(models) {
+    const cheapIndicators = CHEAP_MODEL_INDICATORS;
+    for (const model of [...models].reverse()) {
+        const lower = model.toLowerCase();
+        if (cheapIndicators.some((ind) => lower.includes(ind)))
+            return model;
+    }
+    return models[models.length - 1];
+}

package/dist/token-counter.js

@@ -0,0 +1,47 @@
+import { TOKEN_ESTIMATION } from './constants.js';
+const CODE_CHARS = /[{}()\[\]<>;:,."'`=+\-*/%!&|^~?@#$\\]/g;
+const UNICODE_MULTI = /[\u0080-\uffff]/g;
+const WORD_SPLIT = /\s+/;
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    const len = text.length;
+    if (len < TOKEN_ESTIMATION.simpleCharsPerToken)
+        return 1;
+    const codeChars = (text.match(CODE_CHARS) || []).length;
+    const unicodeChars = (text.match(UNICODE_MULTI) || []).length;
+    const words = text.split(WORD_SPLIT).filter(Boolean).length;
+    const codeRatio = codeChars / len;
+    const charsPerToken = codeRatio > TOKEN_ESTIMATION.codeRatioThreshold
+        ? TOKEN_ESTIMATION.codeCharsPerToken
+        : TOKEN_ESTIMATION.textCharsPerToken;
+    const charEstimate = (len - unicodeChars) / charsPerToken + unicodeChars * TOKEN_ESTIMATION.unicodeTokenMultiplier;
+    const wordEstimate = words * TOKEN_ESTIMATION.wordTokenMultiplier + codeChars * TOKEN_ESTIMATION.codeCharTokenMultiplier;
+    return Math.max(1, Math.ceil(charEstimate * TOKEN_ESTIMATION.charEstimateWeight + wordEstimate * TOKEN_ESTIMATION.wordEstimateWeight));
+}
+function contentToString(content) {
+    if (!content)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    return content
+        .filter((p) => p.type === 'text')
+        .map((p) => p.text)
+        .join('\n');
+}
+export function estimateMessageTokens(messages) {
+    let total = 0;
+    for (const msg of messages) {
+        total += TOKEN_ESTIMATION.messageOverhead;
+        if (msg.content)
+            total += estimateTokens(contentToString(msg.content));
+        if (msg.tool_calls) {
+            for (const tc of msg.tool_calls) {
+                total += estimateTokens(tc.function.name) + estimateTokens(tc.function.arguments) + TOKEN_ESTIMATION.messageOverhead;
+            }
+        }
+        if (msg.name)
+            total += estimateTokens(msg.name);
+    }
+    return total;
+}

package/dist/tool-helper.js

@@ -0,0 +1,97 @@
+export function tool(def) {
+    return def;
+}
+export function zodToJsonSchema(schema) {
+    return convertZod(schema);
+}
+function convertZod(schema) {
+    if (!schema || !schema._def)
+        return { type: 'object' };
+    const def = schema._def;
+    const typeName = def.typeName;
+    switch (typeName) {
+        case 'ZodObject': {
+            const shape = def.shape?.() ?? def.shape ?? {};
+            const properties = {};
+            const required = [];
+            for (const [key, value] of Object.entries(shape)) {
+                const prop = convertZod(value);
+                const isOptional = value?._def?.typeName === 'ZodOptional';
+                if (!isOptional)
+                    required.push(key);
+                properties[key] = prop;
+            }
+            const result = { type: 'object', properties };
+            if (required.length > 0)
+                result.required = required;
+            return result;
+        }
+        case 'ZodString': {
+            const result = { type: 'string' };
+            if (def.description)
+                result.description = def.description;
+            for (const check of def.checks ?? []) {
+                if (check.kind === 'min')
+                    result.minLength = check.value;
+                if (check.kind === 'max')
+                    result.maxLength = check.value;
+                if (check.kind === 'url')
+                    result.format = 'uri';
+            }
+            return result;
+        }
+        case 'ZodNumber': {
+            const result = { type: 'number' };
+            if (def.description)
+                result.description = def.description;
+            for (const check of def.checks ?? []) {
+                if (check.kind === 'min')
+                    result.minimum = check.value;
+                if (check.kind === 'max')
+                    result.maximum = check.value;
+            }
+            return result;
+        }
+        case 'ZodBoolean':
+            return { type: 'boolean', ...(def.description ? { description: def.description } : {}) };
+        case 'ZodArray': {
+            const result = { type: 'array', items: convertZod(def.type) };
+            if (def.description)
+                result.description = def.description;
+            return result;
+        }
+        case 'ZodOptional': {
+            const inner = convertZod(def.innerType);
+            if (def.description)
+                inner.description = def.description;
+            return inner;
+        }
+        case 'ZodDefault':
+            return convertZod(def.innerType);
+        case 'ZodEnum':
+            return { type: 'string', enum: def.values };
+        case 'ZodRecord': {
+            const result = { type: 'object', additionalProperties: convertZod(def.valueType) };
+            return result;
+        }
+        case 'ZodUnion':
+        case 'ZodDiscriminatedUnion': {
+            const options = def.options ?? [];
+            const schemas = options.map((o) => convertZod(o));
+            return schemas.length === 1 ? schemas[0] : { anyOf: schemas };
+        }
+        case 'ZodLiteral': {
+            const v = def.value;
+            return { type: typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'string', const: v };
+        }
+        case 'ZodNullable': {
+            const inner = convertZod(def.innerType);
+            return { ...inner, nullable: true };
+        }
+        case 'ZodEffects':
+        case 'ZodPipeline':
+            return convertZod(def.schema ?? def.innerType);
+        default:
+            return { type: 'string' };
+    }
+}

package/dist/tool-selector.js

@@ -0,0 +1,77 @@
+const CORE_TOOL_NAMES = new Set([
+    'read_file',
+    'write_file',
+    'run_command',
+    'list_files',
+    'edit_file',
+    'search_files',
+    'find_files',
+    'todo_write',
+    'monitor',
+]);
+const CONTEXT_PATTERNS = [
+    [/\b(search|find|grep|look\s+for|where)\b/i, /search|find|grep/],
+    [/\b(git|commit|diff|branch|push|pull|merge|rebase)\b/i, /git/],
+    [/\b(web|url|http|fetch|browse|search\s+online|internet)\b/i, /web|fetch/],
+    [/\b(file|read|write|edit|create|open|save)\b/i, /file|read|write|edit/],
+    [/\b(tree|structure|directory|folder|layout|project)\b/i, /tree|list|find/],
+    [/\b(math|calc|compute|formula|equation)\b/i, /calc/],
+    [/\b(time|date|now|today|clock)\b/i, /time/],
+    [/\b(line|lines|range|portion|section)\b/i, /lines|read/],
+    [/\b(notebook|ipynb)\b|\.ipynb/i, /notebook/],
+    [/\b(sub[\s_-]?agent|delegate|parallel|spawn)\b/i, /agent/],
+    [/\b(task|todo|plan|track|progress)\b/i, /todo/],
+    [/\b(background|process|pid|monitor)\b/i, /monitor/],
+    [/\b(run|exec|shell|command|terminal|bash|script)\b/i, /run_command/],
+    [/\b(mcp|server|connect|sse|integration)\b/i, /mcp/],
+];
+function extractKeywords(text) {
+    const words = text.toLowerCase()
+        .replace(/[^a-z0-9_\s]/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length > 2);
+    return new Set(words);
+}
+export class ToolSelector {
+    toolIndex = [];
+    index(tools) {
+        this.toolIndex = tools.map((t) => {
+            const name = t.function?.name ?? t.name ?? '';
+            const description = t.function?.description ?? t.description ?? '';
+            const keywords = extractKeywords(`${name} ${description}`);
+            return { tool: t, name, keywords, isCore: CORE_TOOL_NAMES.has(name) };
+        });
+    }
+    select(query, recentToolNames = [], maxTools = 64) {
+        if (this.toolIndex.length <= maxTools) {
+            return this.toolIndex.map((t) => t.tool);
+        }
+        const queryKeywords = extractKeywords(query);
+        const recentSet = new Set(recentToolNames);
+        const scored = this.toolIndex.map((info) => {
+            let score = 0;
+            if (info.isCore)
+                score += 10;
+            if (recentSet.has(info.name))
+                score += 5;
+            for (const kw of queryKeywords) {
+                if (info.keywords.has(kw))
+                    score += 2;
+                for (const tk of info.keywords) {
+                    if (tk.includes(kw) || kw.includes(tk))
+                        score += 1;
+                }
+            }
+            for (const [queryPattern, namePattern] of CONTEXT_PATTERNS) {
+                if (queryPattern.test(query) && namePattern.test(info.name))
+                    score += 3;
+            }
+            return { info, score };
+        });
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, maxTools).map((s) => s.info.tool);
+    }
+    getToolNames() {
+        return this.toolIndex.map((t) => t.name);
+    }
+}