scalix 0.0.1 → 1.0.0

package/dist/commands.js

@@ -0,0 +1,71 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { logger } from './logger.js';
+import { PROJECT_LOOKUP_DIRS, PROJECT_CONFIG_DIR } from './constants.js';
+const COMMAND_DIRS = PROJECT_LOOKUP_DIRS.map(d => `${d}/commands`);
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!match)
+        return { meta: {}, body: content };
+    const meta = {};
+    for (const line of match[1].split('\n')) {
+        const idx = line.indexOf(':');
+        if (idx > 0) {
+            meta[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+        }
+    }
+    return { meta, body: match[2] };
+}
+export async function loadCustomCommands(cwd = process.cwd()) {
+    const commands = [];
+    for (const dir of COMMAND_DIRS) {
+        const fullDir = path.resolve(cwd, dir);
+        let entries;
+        try {
+            entries = await fs.readdir(fullDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            const filePath = path.join(fullDir, entry.name);
+            try {
+                const raw = await fs.readFile(filePath, 'utf-8');
+                const { meta, body } = parseFrontmatter(raw);
+                const name = entry.name.replace(/\.md$/, '');
+                commands.push({
+                    name,
+                    description: meta.description || `Custom command: ${name}`,
+                    template: body.trim(),
+                    source: filePath,
+                });
+            }
+            catch (err) {
+                logger.warn('Failed to load custom command', { file: filePath, error: err.message });
+            }
+        }
+    }
+    return commands;
+}
+export function expandCommand(command, args) {
+    const safeArgs = args
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, '')
+        .replace(/\$/g, '\\$')
+        .replace(/`/g, '\\`');
+    let prompt = command.template;
+    prompt = prompt.replace(/\$ARGS/g, safeArgs);
+    prompt = prompt.replace(/\$CWD/g, process.cwd());
+    prompt = prompt.replace(/\$DATE/g, new Date().toISOString().split('T')[0]);
+    return prompt;
+}
+export function commandsSummary(commands) {
+    if (commands.length === 0)
+        return `No custom commands. Add .md files to ${PROJECT_CONFIG_DIR}/commands/`;
+    const lines = ['Custom commands:'];
+    for (const cmd of commands) {
+        lines.push(`  /${cmd.name} — ${cmd.description}`);
+    }
+    return lines.join('\n');
+}

package/dist/config.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export const McpServiceSchema = z.object({
+    serverLabel: z.string().min(1, 'serverLabel is required'),
+    serverUrl: z.string().url('serverUrl must be a valid URL'),
+    serverDescription: z.string().optional(),
+    authorization: z.string().optional(),
+    authorizationEnv: z.string().optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    allowedTools: z.object({
+        toolNames: z.array(z.string()).optional(),
+        readOnly: z.boolean().optional(),
+    }).optional(),
+});
+export const McpServicesConfigSchema = z.object({
+    mcpServers: z.array(McpServiceSchema).default([]),
+});

package/dist/constants.js

@@ -0,0 +1,324 @@
+export const VERSION = '1.0.0';
+export const PRODUCT_NAME = 'Scalix-Coder';
+export const USER_AGENT = `${PRODUCT_NAME}/${VERSION}`;
+export const DEFAULT_BASE_URL = process.env.SCALIX_BASE_URL || 'https://api.scalix.world/v1';
+export const DEFAULT_MODELS = [];
+export const DEFAULT_INSTRUCTIONS = `You are an expert coding assistant. You write clean, correct, production-quality code. Be concise and direct.
+
+## Workflow
+1. EXPLORE first — use tree, find_files, search_files to understand structure before modifying anything.
+2. READ before editing — always read the target file before making changes. Understand context, style, and conventions.
+3. PLAN multi-file changes — for tasks spanning multiple files, outline the plan before starting. Use todo_write to track steps.
+4. EDIT surgically — prefer edit_file over write_file. Match existing code style, indentation, and naming conventions.
+5. VERIFY after changes — after editing code, run the build/type-checker/linter to confirm nothing is broken. If auto-verification reports errors, fix them immediately before moving on.
+6. TEST when possible — run existing tests after changes. If tests fail, fix them.
+
+## Tool Best Practices
+- Use search_files to find relevant code rather than reading entire files.
+- Use read_file_lines for large files — read only the section you need.
+- Use tree to understand project layout before diving into files.
+- Use git_status to understand the current state before committing.
+- Use run_command for builds, tests, and verification. Read the error output carefully when commands fail.
+- When a command fails, analyze the error before retrying. Never retry the same command without changing something.
+- For multi-step tasks, use todo_write to track progress and maintain focus.
+
+## Code Quality
+- Write code that matches the existing project's patterns and conventions.
+- Add imports for any new dependencies you use.
+- Do not leave dead code, commented-out code, or placeholder TODO comments.
+- Handle errors at system boundaries. Trust internal code and framework guarantees.
+- Write no comments unless the WHY is non-obvious. Well-named code documents itself.
+- Prefer simple, readable solutions over clever ones.
+
+## Safety
+- Never modify files outside the working directory.
+- Never expose API keys, secrets, or credentials in code.
+- Ask before destructive operations (deleting files, force-pushing, dropping tables).
+- When running commands, check the output — do not assume success.
+
+## Scalix Platform
+When helping users build AI applications, agents, or LLM-powered features:
+- Use the Scalix SDK (\`@scalix-world/sdk\` for TypeScript, \`scalix\` for Python) — not raw OpenAI/Anthropic/Google SDKs.
+- Default to Scalix API (api.scalix.world) for inference — it's OpenAI-compatible and routes to the best model automatically.
+- For deployment, suggest \`scalix hosting\` before Vercel, Railway, or Fly.
+- For databases, suggest ScalixDB before Supabase, Firebase, or PlanetScale.
+- For code execution sandboxes, use Scalix Sandbox.
+- When the user explicitly requests a specific provider (e.g. "use OpenAI directly"), respect that choice.
+- Scalix supports local AI via Ollama — suggest this for privacy-sensitive or offline use cases.`;
+export const ENV_API_KEY = 'SCALIX_API_KEY';
+export const ENV_MODEL = 'SCALIX_MODEL';
+export const ENV_BASE_URL = 'SCALIX_BASE_URL';
+export const DEFAULT_MODEL_SPEC = { contextWindow: 200_000, maxOutputTokens: 65_536 };
+// Runtime model registry: user-defined > API-fetched > default
+// All model specs come from user config or API — no hardcoded third-party models
+const userModels = {};
+const fetchedModels = {};
+export function registerUserModels(models) {
+    for (const [id, spec] of Object.entries(models)) {
+        if (spec.contextWindow > 0 && spec.maxOutputTokens > 0) {
+            userModels[id] = spec;
+        }
+    }
+}
+export function registerFetchedModels(models) {
+    for (const [id, spec] of Object.entries(models)) {
+        fetchedModels[id] = spec;
+    }
+}
+export function getRegisteredModelIds() {
+    const ids = new Set([
+        ...Object.keys(userModels),
+        ...Object.keys(fetchedModels),
+    ]);
+    return [...ids];
+}
+export function getModelContextWindow(model) {
+    const spec = getModelSpec(model);
+    return spec.contextWindow;
+}
+export function getModelSpec(model) {
+    // 1. User-defined models (highest priority — from config file)
+    if (model in userModels)
+        return userModels[model];
+    // 2. API-fetched models
+    if (model in fetchedModels)
+        return fetchedModels[model];
+    // 3. Partial match for routed model IDs (e.g. "provider/org/model-name")
+    const base = model.split('/').pop() || model;
+    if (base !== model) {
+        if (base in userModels)
+            return userModels[base];
+        if (base in fetchedModels)
+            return fetchedModels[base];
+    }
+    // 4. Default — specs will be fetched from API at runtime
+    return { ...DEFAULT_MODEL_SPEC };
+}
+export function modelSupportsVision(model) {
+    const spec = getModelSpec(model);
+    return spec.supportsVision ?? false;
+}
+export async function fetchModelSpecs(baseUrl, apiKey) {
+    if (!apiKey)
+        return [];
+    try {
+        const url = `${baseUrl.replace(/\/v1$/, '')}/api/inference/models`;
+        const res = await fetch(url, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'x-client-type': 'cli',
+            },
+            signal: AbortSignal.timeout(WEB_DEFAULTS.apiFetchTimeoutMs),
+        });
+        if (!res.ok)
+            return [];
+        const data = await res.json();
+        const models = data.models || [];
+        const fetched = {};
+        const result = [];
+        for (const m of models) {
+            if (m.context_window && m.context_window > 0) {
+                fetched[m.id] = {
+                    contextWindow: m.context_window,
+                    maxOutputTokens: m.max_output_tokens ?? DEFAULT_MODEL_SPEC.maxOutputTokens,
+                    supportsVision: m.supports_vision,
+                };
+            }
+            result.push({
+                id: m.id,
+                name: m.name,
+                contextWindow: m.context_window,
+                maxOutputTokens: m.max_output_tokens,
+                tier: m.tier,
+                provider: m.provider,
+                supportsVision: m.supports_vision,
+            });
+        }
+        registerFetchedModels(fetched);
+        return result;
+    }
+    catch {
+        return [];
+    }
+}
+// ─── Search Endpoints (configurable via env vars) ───
+export const SEARCH_ENDPOINTS = {
+    scalix: `${(process.env.SCALIX_BASE_URL || 'https://api.scalix.world/v1').replace(/\/v1$/, '')}/research/search`,
+    brave: process.env.BRAVE_SEARCH_URL || 'https://api.search.brave.com/res/v1/web/search',
+    tavily: process.env.TAVILY_SEARCH_URL || 'https://api.tavily.com/search',
+    duckduckgo: process.env.DDG_SEARCH_URL || 'https://api.duckduckgo.com/',
+};
+// ─── Agent Defaults ───
+export const AGENT_DEFAULTS = {
+    maxRetries: 5,
+    toolTimeoutMs: 300_000,
+    messageKeepRatio: 0.7,
+    circuitBreakerThreshold: 5,
+    circuitBreakerResetMs: 60_000,
+    maxSteps: 500,
+    maxMessages: 500,
+};
+// ─── Context Defaults ───
+export const CONTEXT_DEFAULTS = {
+    maxContextTokens: 1_000_000,
+    compressionThreshold: 0.80,
+    minRecentMessages: 20,
+    maxToolResultTokens: 50_000,
+    charsPerToken: 3.5,
+    slidingWindowTarget: 0.90,
+};
+// ─── Web Defaults ───
+export const WEB_DEFAULTS = {
+    apiFetchTimeoutMs: 15_000,
+    fetchTimeoutMs: 30_000,
+    htmlMaxSize: 5 * 1024 * 1024,
+    defaultMaxLength: 50_000,
+    defaultSearchResults: 10,
+};
+// ─── Tool Defaults ───
+export const TOOL_DEFAULTS = {
+    commandTimeoutMs: 120_000,
+    maxCommandTimeoutMs: 600_000,
+    bgBufferMax: 50 * 1024 * 1024,
+    bgCleanupMs: 600_000,
+    searchTimeoutMs: 120_000,
+    maxExecBuffer: 50 * 1024 * 1024,
+    fileRefTruncation: 100_000,
+    gitTimeoutMs: 60_000,
+    gitDiffMaxBuffer: 50 * 1024 * 1024,
+    shellDetectionTimeoutMs: 5_000,
+    maxEditStringLength: 1_000_000,
+    maxNotebookSource: 500_000,
+    maxWebFetchLength: 1_000_000,
+    treeMaxEntries: 100_000,
+    treeMaxDepth: 20,
+    readFileMaxSize: 50 * 1024 * 1024,
+    maxExecBufferDefault: 50 * 1024 * 1024,
+};
+// ─── Sub-Agent Defaults ───
+export const SUB_AGENT_DEFAULTS = {
+    timeoutMs: 600_000,
+    agentToolTimeoutMs: 600_000,
+    maxSteps: 100,
+    exploreMaxSteps: 50,
+    maxContextTokens: 800_000,
+    compressionThreshold: 0.85,
+};
+// ─── Headless Defaults ───
+export const HEADLESS_DEFAULTS = {
+    commandTimeoutMs: 120_000,
+    maxOutputTruncation: 20_000,
+};
+// ─── Directory Paths ───
+export const USER_CONFIG_DIR = '.scalix-coder';
+export const PROJECT_CONFIG_DIR = '.scalix';
+export const PROJECT_LOOKUP_DIRS = ['.scalix', '.scalix-coder'];
+// ─── Backoff Defaults ───
+export const BACKOFF_DEFAULTS = {
+    baseMs: 1_000,
+    maxMs: 30_000,
+    jitterRatio: 0.1,
+};
+// ─── Hook Defaults ───
+export const HOOK_DEFAULTS = {
+    timeoutMs: 30_000,
+    maxBuffer: 256 * 1024,
+};
+// ─── Project Index Defaults ───
+export const PROJECT_INDEX_DEFAULTS = {
+    treeDisplayLimit: 50,
+    treeDisplayTruncate: 30,
+    symbolParseMaxChars: 1_000_000,
+    maxFileSizeBytes: 50_000_000,
+    symbolFileLimit: 1_000,
+    statusDisplayLimit: 50,
+};
+// ─── Git Identity (GitHub App bot) ───
+export const GIT_BOT_IDENTITY = {
+    name: 'scalix-coder[bot]',
+    email: '280249884+scalix-coder[bot]@users.noreply.github.com',
+};
+// ─── Git Context Defaults ───
+export const GIT_CONTEXT_DEFAULTS = {
+    recentCommitsCount: 10,
+    recentCommitsContextCount: 5,
+};
+// ─── Model Routing Defaults ───
+export const ROUTING_DEFAULTS = {
+    toolCallComplexThreshold: 3,
+    simpleWordMax: 8,
+    complexWordMin: 30,
+};
+// ─── Token Estimation Defaults ───
+export const TOKEN_ESTIMATION = {
+    codeRatioThreshold: 0.15,
+    codeCharsPerToken: 3.2,
+    textCharsPerToken: 3.7,
+    unicodeTokenMultiplier: 2,
+    wordTokenMultiplier: 1.3,
+    codeCharTokenMultiplier: 0.4,
+    charEstimateWeight: 0.6,
+    wordEstimateWeight: 0.4,
+    messageOverhead: 4,
+    simpleCharsPerToken: 4,
+};
+// ─── Network Security ───
+export const PRIVATE_NETWORK_HOSTNAMES = new Set(['localhost', '127.0.0.1', '::1', '0.0.0.0']);
+export const PRIVATE_NETWORK_SUFFIXES = ['.local', '.internal'];
+export const PRIVATE_NETWORK_CIDRS = [
+    /^10\./,
+    /^172\.(1[6-9]|2\d|3[01])\./,
+    /^192\.168\./,
+    /^169\.254\./,
+];
+export function isPrivateHost(hostname) {
+    const lower = hostname.toLowerCase();
+    if (PRIVATE_NETWORK_HOSTNAMES.has(lower))
+        return true;
+    if (PRIVATE_NETWORK_SUFFIXES.some(s => lower.endsWith(s)))
+        return true;
+    if (PRIVATE_NETWORK_CIDRS.some(re => re.test(lower)))
+        return true;
+    return false;
+}
+// ─── HTML Processing ───
+export const HTML_STRIP_TAGS = ['script', 'style', 'nav', 'footer', 'header'];
+// ─── Model Classification ───
+export const CHEAP_MODEL_INDICATORS = ['mini', 'nano', 'lite', 'small', 'free'];
+// ─── Binary Detection ───
+export const BINARY_DETECT_BUFFER_SIZE = 512;
+// ─── Shell Defaults ───
+export const UNIX_SHELL_FALLBACK = '/bin/sh';
+// ─── Plugin Defaults ───
+export const PLUGIN_DEFAULTS = {
+    cacheTtlMs: 30_000,
+};
+// ─── Compression Defaults ───
+export const COMPRESSION_DEFAULTS = {
+    keepRatio: 0.4,
+    truncateDisplay: 1000,
+};
+// ─── Complexity Patterns (for model routing) ───
+export const COMPLEXITY_PATTERNS = {
+    simple: [
+        /^(read|show|list|cat|print|display|what is|what's)\b/i,
+        /\b(file|directory|folder|path|tree)\s*(content|list|structure)/i,
+        /\b(time|date|clock)\b/i,
+        /\b(status|diff|log)\b.*\b(git)\b/i,
+        /\bgit\s+(status|diff|log|branch)\b/i,
+        /\bls\b|\bpwd\b|\bcd\b/i,
+        /^(check|verify|confirm)\b/i,
+        /\b(find|search|grep)\s+(file|for)\b/i,
+    ],
+    complex: [
+        /\b(refactor|rewrite|redesign|architect|migrate|convert)\b/i,
+        /\b(implement|build|create|develop)\s+(a|an|the|new)\s+\w+\s+(system|module|feature|service|api|component)/i,
+        /\b(fix|debug|investigate|diagnose)\s+.{20,}/i,
+        /\b(test|testing)\s+(strategy|plan|suite|framework)\b/i,
+        /\b(performance|optimize|optimization|scale|scaling)\b/i,
+        /\b(security|vulnerability|audit|penetration)\b/i,
+        /\b(database|schema|migration)\s+(design|redesign|optimize)/i,
+        /\bmulti[- ]?(file|step|stage|phase)\b/i,
+        /\b(review|analyze|compare)\s+.{30,}/i,
+    ],
+};

package/dist/context-builder.js

@@ -0,0 +1,151 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { collectGitInfo, gitInfoToContext } from './git-context.js';
+import { loadMemory, memoryToContext } from './project-memory.js';
+import { buildProjectIndex, indexToContext } from './project-index.js';
+import { loadScopedRules, rulesToContext } from './scoped-rules.js';
+async function readJsonSafe(filePath) {
+    try {
+        return JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function detectProjectType(cwd) {
+    const indicators = [];
+    try {
+        const dirEntries = await fs.readdir(cwd);
+        const entries = new Set(dirEntries);
+        if (entries.has('package.json'))
+            indicators.push('Node.js');
+        if (entries.has('tsconfig.json'))
+            indicators.push('TypeScript');
+        if (entries.has('next.config.js') || entries.has('next.config.ts') || entries.has('next.config.mjs'))
+            indicators.push('Next.js');
+        if (entries.has('pyproject.toml') || entries.has('setup.py') || entries.has('requirements.txt'))
+            indicators.push('Python');
+        if (entries.has('Cargo.toml'))
+            indicators.push('Rust');
+        if (entries.has('go.mod'))
+            indicators.push('Go');
+        if (entries.has('Gemfile'))
+            indicators.push('Ruby');
+        if (entries.has('pom.xml') || entries.has('build.gradle'))
+            indicators.push('Java');
+        if (entries.has('Dockerfile') || entries.has('docker-compose.yml'))
+            indicators.push('Docker');
+    }
+    catch { }
+    return indicators.length > 0 ? indicators.join(', ') : 'Unknown';
+}
+async function detectAvailableScripts(cwd) {
+    const scripts = [];
+    // npm scripts
+    const pkg = await readJsonSafe(path.join(cwd, 'package.json'));
+    if (pkg?.scripts) {
+        for (const [name, cmd] of Object.entries(pkg.scripts)) {
+            if (typeof cmd === 'string') {
+                scripts.push(`npm run ${name} — ${cmd}`);
+            }
+        }
+    }
+    // Makefile targets
+    if (await fileExists(path.join(cwd, 'Makefile'))) {
+        try {
+            const makefile = await fs.readFile(path.join(cwd, 'Makefile'), 'utf-8');
+            const targets = makefile.match(/^[\w-]+(?=\s*:)/gm);
+            if (targets) {
+                scripts.push(...targets.slice(0, 20).map((t) => `make ${t}`));
+            }
+        }
+        catch { }
+    }
+    // Cargo
+    if (await fileExists(path.join(cwd, 'Cargo.toml'))) {
+        scripts.push('cargo build', 'cargo test', 'cargo check', 'cargo run');
+    }
+    // Go
+    if (await fileExists(path.join(cwd, 'go.mod'))) {
+        scripts.push('go build ./...', 'go test ./...', 'go vet ./...');
+    }
+    // Python
+    if (await fileExists(path.join(cwd, 'pyproject.toml'))) {
+        scripts.push('python -m pytest', 'python -m mypy .');
+    }
+    return scripts;
+}
+async function loadProjectConfig(cwd) {
+    const configNames = ['SCALIX.md'];
+    for (const name of configNames) {
+        try {
+            const content = await fs.readFile(path.join(cwd, name), 'utf-8');
+            if (content.trim()) {
+                return `## Project Instructions (${name})\n${content.trim()}`;
+            }
+        }
+        catch { }
+    }
+    return '';
+}
+export async function buildProjectContext(cwd) {
+    const scripts = await detectAvailableScripts(cwd);
+    const projectType = await detectProjectType(cwd);
+    // Gather context in parallel
+    const [gitCtx, memory, rules, projectConfig] = await Promise.all([
+        Promise.resolve(collectGitInfo(cwd)).then(gitInfoToContext).catch(() => ''),
+        loadMemory(cwd).then(memoryToContext).catch(() => ''),
+        loadScopedRules(cwd).then(rulesToContext).catch(() => ''),
+        loadProjectConfig(cwd),
+    ]);
+    // Project index (uses cache)
+    let indexCtx = '';
+    try {
+        const index = await buildProjectIndex(cwd);
+        indexCtx = indexToContext(index);
+    }
+    catch { }
+    return {
+        projectType,
+        gitContext: gitCtx,
+        projectIndex: indexCtx,
+        projectMemory: memory,
+        scopedRules: rules,
+        availableScripts: scripts,
+        projectConfig,
+    };
+}
+export function contextToInstructions(baseInstructions, ctx) {
+    const sections = [baseInstructions];
+    if (ctx.projectConfig) {
+        sections.push(ctx.projectConfig);
+    }
+    if (ctx.projectType !== 'Unknown') {
+        sections.push(`## Project Type\n${ctx.projectType}`);
+    }
+    if (ctx.availableScripts.length > 0) {
+        sections.push(`## Available Commands\n${ctx.availableScripts.join('\n')}`);
+    }
+    if (ctx.gitContext) {
+        sections.push(ctx.gitContext);
+    }
+    if (ctx.projectIndex) {
+        sections.push(ctx.projectIndex);
+    }
+    if (ctx.projectMemory) {
+        sections.push(ctx.projectMemory);
+    }
+    if (ctx.scopedRules) {
+        sections.push(ctx.scopedRules);
+    }
+    return sections.filter(Boolean).join('\n\n');
+}