scalix 1.0.0 → 1.2.0

package/dist/commands.js

@@ -1,5 +1,7 @@
 import fs from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
+import { execSync } from 'node:child_process';
 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`);
@@ -16,6 +18,9 @@ function parseFrontmatter(content) {
     }
     return { meta, body: match[2] };
 }
+function parseAllowedTools(spec) {
+    return spec.split(',').map(s => s.trim()).filter(Boolean);
+}
 export async function loadCustomCommands(cwd = process.cwd()) {
     const commands = [];
     for (const dir of COMMAND_DIRS) {
@@ -35,11 +40,17 @@ export async function loadCustomCommands(cwd = process.cwd()) {
                 const raw = await fs.readFile(filePath, 'utf-8');
                 const { meta, body } = parseFrontmatter(raw);
                 const name = entry.name.replace(/\.md$/, '');
+                const fm = meta;
                 commands.push({
                     name,
-                    description: meta.description || `Custom command: ${name}`,
+                    description: fm.description || `Custom command: ${name}`,
                     template: body.trim(),
                     source: filePath,
+                    frontmatter: fm,
+                    allowedTools: fm['allowed-tools'] ? parseAllowedTools(fm['allowed-tools']) : undefined,
+                    model: fm.model || undefined,
+                    argumentHint: fm['argument-hint'] || undefined,
+                    disableModelInvocation: fm['disable-model-invocation'] === 'true',
                 });
             }
             catch (err) {
@@ -49,15 +60,52 @@ export async function loadCustomCommands(cwd = process.cwd()) {
     }
     return commands;
 }
+function expandFileReferences(text, cwd) {
+    return text.replace(/@([\w./-]+\.\w+)/g, (_match, filePath) => {
+        const resolved = path.resolve(cwd, filePath);
+        if (!existsSync(resolved))
+            return `@${filePath} (file not found)`;
+        try {
+            const content = readFileSync(resolved, 'utf-8');
+            return `\n<file path="${filePath}">\n${content}\n</file>\n`;
+        }
+        catch {
+            return `@${filePath} (read error)`;
+        }
+    });
+}
+function expandInlineBash(text) {
+    return text.replace(/!`([^`]+)`/g, (_match, command) => {
+        try {
+            return execSync(command, { encoding: 'utf-8', timeout: 10_000 }).trim();
+        }
+        catch (err) {
+            return `(command failed: ${err.message})`;
+        }
+    });
+}
+function expandPositionalArgs(text, args) {
+    const parts = args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+    const cleaned = parts.map(p => p.replace(/^["']|["']$/g, ''));
+    let result = text;
+    for (let i = 0; i < 9; i++) {
+        const placeholder = `$${i + 1}`;
+        result = result.split(placeholder).join(cleaned[i] || '');
+    }
+    return result;
+}
 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 = expandPositionalArgs(prompt, args);
     prompt = prompt.replace(/\$ARGS/g, safeArgs);
     prompt = prompt.replace(/\$CWD/g, process.cwd());
     prompt = prompt.replace(/\$DATE/g, new Date().toISOString().split('T')[0]);
+    prompt = expandFileReferences(prompt, process.cwd());
+    prompt = expandInlineBash(prompt);
     return prompt;
 }
 export function commandsSummary(commands) {
@@ -65,7 +113,10 @@ export function commandsSummary(commands) {
         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}`);
+        const hint = cmd.argumentHint ? ` <${cmd.argumentHint}>` : '';
+        const model = cmd.model ? ` [model: ${cmd.model}]` : '';
+        const tools = cmd.allowedTools ? ` [tools: ${cmd.allowedTools.length}]` : '';
+        lines.push(`  /${cmd.name}${hint} — ${cmd.description}${model}${tools}`);
     }
     return lines.join('\n');
 }

package/dist/constants.js

@@ -1,4 +1,4 @@
-export const VERSION = '1.0.0';
+export const VERSION = '1.1.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';
@@ -199,10 +199,16 @@ export const TOOL_DEFAULTS = {
 export const SUB_AGENT_DEFAULTS = {
     timeoutMs: 600_000,
     agentToolTimeoutMs: 600_000,
-    maxSteps: 100,
-    exploreMaxSteps: 50,
-    maxContextTokens: 800_000,
-    compressionThreshold: 0.85,
+    maxSteps: 500,
+    exploreMaxSteps: 200,
+    maxContextTokens: 1_000_000,
+    compressionThreshold: 0.80,
+};
+// ─── Multi-Agent Defaults ───
+export const MULTI_AGENT_DEFAULTS = {
+    maxConcurrentAgents: 10,
+    maxDepth: 5,
+    globalTokenBudget: 5_000_000,
 };
 // ─── Headless Defaults ───
 export const HEADLESS_DEFAULTS = {
@@ -233,10 +239,10 @@ export const PROJECT_INDEX_DEFAULTS = {
     symbolFileLimit: 1_000,
     statusDisplayLimit: 50,
 };
-// ─── Git Identity (GitHub App bot) ───
+// ─── Git Identity ───
 export const GIT_BOT_IDENTITY = {
-    name: 'scalix-coder[bot]',
-    email: '280249884+scalix-coder[bot]@users.noreply.github.com',
+    name: 'Scalix Coder',
+    email: '283104927+scalix-coder@users.noreply.github.com',
 };
 // ─── Git Context Defaults ───
 export const GIT_CONTEXT_DEFAULTS = {
@@ -263,16 +269,37 @@ export const TOKEN_ESTIMATION = {
     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_HOSTNAMES = new Set([
+    'localhost', '127.0.0.1', '::1', '[::1]', '0.0.0.0',
+    '::ffff:127.0.0.1', '[::ffff:127.0.0.1]',
+]);
 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\./,
+    /^\[?fe80:/i,
+    /^\[?fc00:/i,
+    /^\[?fd[0-9a-f]{2}:/i,
+    /^\[?::ffff:(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.|127\.)/i,
 ];
+let _networkOverrides = {};
+export function setNetworkSecurityOverrides(overrides) {
+    _networkOverrides = {
+        allowAll: overrides.allowAll,
+        blockedHosts: overrides.blockedHosts ? new Set(overrides.blockedHosts.map(h => h.toLowerCase())) : undefined,
+        allowedHosts: overrides.allowedHosts ? new Set(overrides.allowedHosts.map(h => h.toLowerCase())) : undefined,
+    };
+}
 export function isPrivateHost(hostname) {
     const lower = hostname.toLowerCase();
+    if (_networkOverrides.allowAll)
+        return false;
+    if (_networkOverrides.allowedHosts?.has(lower))
+        return false;
+    if (_networkOverrides.blockedHosts?.has(lower))
+        return true;
     if (PRIVATE_NETWORK_HOSTNAMES.has(lower))
         return true;
     if (PRIVATE_NETWORK_SUFFIXES.some(s => lower.endsWith(s)))
@@ -298,6 +325,13 @@ export const COMPRESSION_DEFAULTS = {
     keepRatio: 0.4,
     truncateDisplay: 1000,
 };
+// ─── Update Check Defaults ───
+export const UPDATE_DEFAULTS = {
+    checkIntervalMs: 24 * 60 * 60 * 1000,
+    registryUrl: 'https://registry.npmjs.org/scalix/latest',
+    fetchTimeoutMs: 5_000,
+    npmPackageName: 'scalix',
+};
 // ─── Complexity Patterns (for model routing) ───
 export const COMPLEXITY_PATTERNS = {
     simple: [

package/dist/context-builder.js

@@ -4,6 +4,7 @@ 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';
+import { retrieveContext, snippetsToContext, RETRIEVAL_DEFAULTS } from './context-retriever.js';
 async function readJsonSafe(filePath) {
     try {
         return JSON.parse(await fs.readFile(filePath, 'utf-8'));
@@ -102,7 +103,7 @@ export async function buildProjectContext(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(() => ''),
+        collectGitInfo(cwd).then(gitInfoToContext).catch(() => ''),
         loadMemory(cwd).then(memoryToContext).catch(() => ''),
         loadScopedRules(cwd).then(rulesToContext).catch(() => ''),
         loadProjectConfig(cwd),
@@ -149,3 +150,9 @@ export function contextToInstructions(baseInstructions, ctx) {
     }
     return sections.filter(Boolean).join('\n\n');
 }
+export async function buildQueryContext(query, cwd, config) {
+    const index = await buildProjectIndex(cwd);
+    const effectiveConfig = config ? { ...RETRIEVAL_DEFAULTS, ...config } : RETRIEVAL_DEFAULTS;
+    const result = await retrieveContext(query, index, effectiveConfig);
+    return snippetsToContext(result.snippets);
+}

package/dist/context-retriever.js

@@ -0,0 +1,257 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { estimateTokens } from './token-counter.js';
+export const RETRIEVAL_DEFAULTS = {
+    enabled: true,
+    maxSnippets: 5,
+    maxTokensPerSnippet: 500,
+    maxTotalTokens: 3000,
+    previewLines: 30,
+    minRelevanceScore: 0.3,
+};
+const STOP_WORDS = new Set([
+    'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been',
+    'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'from',
+    'and', 'or', 'but', 'not', 'no', 'so', 'if', 'then', 'else',
+    'do', 'does', 'did', 'will', 'would', 'should', 'could', 'can',
+    'has', 'have', 'had', 'this', 'that', 'these', 'those',
+    'it', 'its', 'i', 'me', 'my', 'we', 'our', 'you', 'your',
+    'he', 'she', 'they', 'them', 'what', 'which', 'who', 'how',
+    'when', 'where', 'why', 'all', 'each', 'every', 'any', 'some',
+    'about', 'up', 'out', 'just', 'also', 'than', 'very',
+    'code', 'file', 'function', 'change', 'make', 'use', 'using',
+    'want', 'need', 'like', 'please', 'help', 'show', 'get',
+]);
+const FILE_HINT_RE = /(?:^|[\s`"'(])([.\w][\w./-]*\/[\w./-]+\.\w{1,10})(?=[\s`"'),.:;]|$)/gm;
+const CAMEL_RE = /\b([A-Z][a-zA-Z]{2,})\b/g;
+const SNAKE_RE = /\b([a-z][a-z0-9]*(?:_[a-z0-9]+){1,})\b/g;
+const INTENT_PATTERNS = {
+    debug: /\b(?:fix|debug|error|bug|broken|crash|fail|issue|wrong|problem)\b/i,
+    create: /\b(?:create|add|new|implement|build|generate|write|introduce)\b/i,
+    modify: /\b(?:change|update|modify|refactor|rename|move|replace|improve|optimize)\b/i,
+    explore: /\b(?:read|show|explain|understand|find|search|look|what|where|how|list|describe)\b/i,
+    general: /./,
+};
+export function analyzeQuery(query) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const keywords = words.filter((w) => !STOP_WORDS.has(w) && w.length > 2);
+    const fileHints = [];
+    for (const m of query.matchAll(FILE_HINT_RE)) {
+        fileHints.push(m[1]);
+    }
+    const symbolHints = [];
+    for (const m of query.matchAll(CAMEL_RE)) {
+        symbolHints.push(m[1]);
+    }
+    for (const m of query.matchAll(SNAKE_RE)) {
+        symbolHints.push(m[1]);
+    }
+    let intentType = 'general';
+    for (const [intent, re] of Object.entries(INTENT_PATTERNS)) {
+        if (intent === 'general')
+            continue;
+        if (re.test(query)) {
+            intentType = intent;
+            break;
+        }
+    }
+    return { keywords, fileHints, symbolHints, intentType };
+}
+function scoreFiles(analysis, index) {
+    const symbolsByFile = new Map();
+    for (const sym of index.symbols) {
+        const existing = symbolsByFile.get(sym.file) ?? [];
+        existing.push(sym);
+        symbolsByFile.set(sym.file, existing);
+    }
+    const importGraph = new Map();
+    for (const imp of index.imports) {
+        const deps = importGraph.get(imp.from) ?? new Set();
+        deps.add(imp.to);
+        importGraph.set(imp.from, deps);
+    }
+    const recentFiles = new Set(index.files
+        .sort((a, b) => b.modifiedAt - a.modifiedAt)
+        .slice(0, 20)
+        .map((f) => f.relativePath));
+    const directMentionFiles = new Set();
+    for (const hint of analysis.fileHints) {
+        for (const f of index.files) {
+            if (f.relativePath === hint || f.relativePath.endsWith(hint)) {
+                directMentionFiles.add(f.relativePath);
+            }
+        }
+    }
+    const scores = [];
+    for (const file of index.files) {
+        let score = 0;
+        const reasons = [];
+        const matchingSymbols = [];
+        // Direct file mention
+        if (directMentionFiles.has(file.relativePath)) {
+            score += 1.0;
+            reasons.push('directly mentioned');
+        }
+        // Symbol match
+        const fileSymbols = symbolsByFile.get(file.relativePath) ?? [];
+        for (const sym of fileSymbols) {
+            const nameLower = sym.name.toLowerCase();
+            if (analysis.symbolHints.some((h) => h.toLowerCase() === nameLower)) {
+                score += 0.6;
+                matchingSymbols.push(sym.name);
+                reasons.push(`symbol "${sym.name}"`);
+            }
+            else if (analysis.keywords.some((k) => nameLower.includes(k))) {
+                score += 0.3;
+                matchingSymbols.push(sym.name);
+                reasons.push(`keyword in symbol "${sym.name}"`);
+            }
+        }
+        // Import proximity — file is imported by a directly-mentioned file
+        for (const mentionedFile of directMentionFiles) {
+            const deps = importGraph.get(mentionedFile);
+            if (deps?.has(file.relativePath)) {
+                score += 0.3;
+                reasons.push(`imported by ${mentionedFile}`);
+            }
+        }
+        // Keyword in path
+        const pathLower = file.relativePath.toLowerCase();
+        for (const kw of analysis.keywords) {
+            if (pathLower.includes(kw)) {
+                score += 0.2;
+                reasons.push(`keyword "${kw}" in path`);
+            }
+        }
+        // Recency bonus
+        if (recentFiles.has(file.relativePath)) {
+            score += 0.1;
+            reasons.push('recently modified');
+        }
+        if (score > 0) {
+            scores.push({
+                file: file.relativePath,
+                score: Math.min(score, 2.0),
+                matchingSymbols,
+                reason: reasons.join(', '),
+            });
+        }
+    }
+    return scores.sort((a, b) => b.score - a.score);
+}
+async function generatePreview(filePath, projectRoot, matchingSymbols, maxLines) {
+    try {
+        const absPath = path.join(projectRoot, filePath);
+        const content = await fs.readFile(absPath, 'utf-8');
+        const lines = content.split('\n');
+        if (matchingSymbols.length > 0) {
+            // Show lines around matching symbols
+            const ranges = [];
+            for (const sym of matchingSymbols.slice(0, 3)) {
+                const start = Math.max(0, sym.line - 2);
+                const end = Math.min(lines.length - 1, sym.line + 8);
+                ranges.push([start, end]);
+            }
+            // Merge overlapping ranges
+            ranges.sort((a, b) => a[0] - b[0]);
+            const merged = [ranges[0]];
+            for (let i = 1; i < ranges.length; i++) {
+                const prev = merged[merged.length - 1];
+                if (ranges[i][0] <= prev[1] + 2) {
+                    prev[1] = Math.max(prev[1], ranges[i][1]);
+                }
+                else {
+                    merged.push(ranges[i]);
+                }
+            }
+            const parts = [];
+            let totalLines = 0;
+            for (const [start, end] of merged) {
+                if (totalLines >= maxLines)
+                    break;
+                const available = maxLines - totalLines;
+                const rangeEnd = Math.min(end, start + available - 1);
+                for (let i = start; i <= rangeEnd; i++) {
+                    parts.push(`${i + 1}\t${lines[i]}`);
+                    totalLines++;
+                }
+                if (rangeEnd < end)
+                    break;
+                parts.push('...');
+            }
+            return parts.join('\n');
+        }
+        // No matching symbols — show first N lines
+        return lines
+            .slice(0, maxLines)
+            .map((l, i) => `${i + 1}\t${l}`)
+            .join('\n');
+    }
+    catch {
+        return '(file could not be read)';
+    }
+}
+export async function retrieveContext(query, index, config = RETRIEVAL_DEFAULTS) {
+    const analysis = analyzeQuery(query);
+    if (analysis.keywords.length === 0 && analysis.fileHints.length === 0 && analysis.symbolHints.length === 0) {
+        return { snippets: [], totalTokens: 0, queryTerms: [] };
+    }
+    const scored = scoreFiles(analysis, index);
+    const candidates = scored.filter((s) => s.score >= config.minRelevanceScore).slice(0, config.maxSnippets);
+    const symbolsByFile = new Map();
+    for (const sym of index.symbols) {
+        const existing = symbolsByFile.get(sym.file) ?? [];
+        existing.push(sym);
+        symbolsByFile.set(sym.file, existing);
+    }
+    const snippets = [];
+    let totalTokens = 0;
+    for (const candidate of candidates) {
+        if (totalTokens >= config.maxTotalTokens)
+            break;
+        const matchingSymbols = (symbolsByFile.get(candidate.file) ?? [])
+            .filter((s) => candidate.matchingSymbols.includes(s.name));
+        const preview = await generatePreview(candidate.file, index.root, matchingSymbols, config.previewLines);
+        let tokens = estimateTokens(preview);
+        let truncatedPreview = preview;
+        if (tokens > config.maxTokensPerSnippet) {
+            const lines = preview.split('\n');
+            const kept = [];
+            let running = 0;
+            for (const line of lines) {
+                const lt = estimateTokens(line);
+                if (running + lt > config.maxTokensPerSnippet)
+                    break;
+                kept.push(line);
+                running += lt;
+            }
+            truncatedPreview = kept.join('\n');
+            tokens = running;
+        }
+        if (totalTokens + tokens > config.maxTotalTokens)
+            break;
+        snippets.push({
+            file: candidate.file,
+            relevanceScore: candidate.score,
+            symbols: candidate.matchingSymbols,
+            preview: truncatedPreview,
+            reason: candidate.reason,
+        });
+        totalTokens += tokens;
+    }
+    return { snippets, totalTokens, queryTerms: analysis.keywords };
+}
+export function snippetsToContext(snippets) {
+    if (snippets.length === 0)
+        return '';
+    const parts = ['## Relevant Code Context',
+        'The following file excerpts may be relevant. Use this as ground truth rather than guessing.\n'];
+    for (const s of snippets) {
+        const symbolStr = s.symbols.length > 0 ? `\nSymbols: ${s.symbols.join(', ')}` : '';
+        parts.push(`### ${s.file} (score: ${s.relevanceScore.toFixed(1)})${symbolStr}`);
+        parts.push('```');
+        parts.push(s.preview);
+        parts.push('```\n');
+    }
+    return parts.join('\n');
+}

package/dist/git-context.js

@@ -1,27 +1,30 @@
-import { execSync } from 'node:child_process';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
 import { TOOL_DEFAULTS, GIT_CONTEXT_DEFAULTS, PROJECT_INDEX_DEFAULTS } from './constants.js';
-function run(cmd, cwd) {
+const execAsync = promisify(exec);
+async function run(cmd, cwd) {
     try {
-        return execSync(cmd, { cwd, encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const { stdout } = await execAsync(cmd, { cwd, encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs });
+        return stdout.trim();
     }
     catch {
         return '';
     }
 }
-function isGitRepo(cwd) {
-    return run('git rev-parse --is-inside-work-tree', cwd) === 'true';
+async function isGitRepo(cwd) {
+    return (await run('git rev-parse --is-inside-work-tree', cwd)) === 'true';
 }
-function getBranch(cwd) {
-    return run('git branch --show-current', cwd) || run('git rev-parse --short HEAD', cwd) || 'unknown';
+async function getBranch(cwd) {
+    return (await run('git branch --show-current', cwd)) || (await run('git rev-parse --short HEAD', cwd)) || 'unknown';
 }
-function getRemoteBranch(cwd) {
+async function getRemoteBranch(cwd) {
     return run('git rev-parse --abbrev-ref @{upstream} 2>/dev/null', cwd);
 }
-function getRemoteUrl(cwd) {
+async function getRemoteUrl(cwd) {
     return run('git remote get-url origin 2>/dev/null', cwd);
 }
-function getAheadBehind(cwd) {
-    const result = run('git rev-list --left-right --count @{upstream}...HEAD 2>/dev/null', cwd);
+async function getAheadBehind(cwd) {
+    const result = await run('git rev-list --left-right --count @{upstream}...HEAD 2>/dev/null', cwd);
     if (!result)
         return { ahead: 0, behind: 0 };
     const parts = result.split('\t');
@@ -29,12 +32,12 @@ function getAheadBehind(cwd) {
         return { ahead: 0, behind: 0 };
     return { ahead: Number(parts[1]) || 0, behind: Number(parts[0]) || 0 };
 }
-function getStashCount(cwd) {
-    const result = run('git stash list 2>/dev/null', cwd);
+async function getStashCount(cwd) {
+    const result = await run('git stash list 2>/dev/null', cwd);
     return result ? result.split('\n').filter(Boolean).length : 0;
 }
-function getStatus(cwd) {
-    const result = run('git status --porcelain', cwd);
+async function getStatus(cwd) {
+    const result = await run('git status --porcelain', cwd);
     if (!result)
         return [];
     return result.split('\n').filter(Boolean).map((line) => {
@@ -68,10 +71,10 @@ function getStatus(cwd) {
         return { path: filePath, status, staged };
     });
 }
-function getRecentCommits(cwd, count = GIT_CONTEXT_DEFAULTS.recentCommitsCount) {
+async function getRecentCommits(cwd, count = GIT_CONTEXT_DEFAULTS.recentCommitsCount) {
     const SEP = '<%>';
     const format = `%H${SEP}%h${SEP}%s${SEP}%an${SEP}%ar`;
-    const result = run(`git log --pretty=format:"${format}" --shortstat -n ${count} 2>/dev/null`, cwd);
+    const result = await run(`git log --pretty=format:"${format}" --shortstat -n ${count} 2>/dev/null`, cwd);
     if (!result)
         return [];
     const commits = [];
@@ -103,8 +106,8 @@ function getRecentCommits(cwd, count = GIT_CONTEXT_DEFAULTS.recentCommitsCount)
     }
     return commits;
 }
-export function collectGitInfo(cwd) {
-    if (!isGitRepo(cwd)) {
+export async function collectGitInfo(cwd) {
+    if (!(await isGitRepo(cwd))) {
         return {
             isRepo: false,
             branch: '',
@@ -116,16 +119,16 @@ export function collectGitInfo(cwd) {
             remoteUrl: '',
         };
     }
-    return {
-        isRepo: true,
-        branch: getBranch(cwd),
-        remoteBranch: getRemoteBranch(cwd),
-        status: getStatus(cwd),
-        recentCommits: getRecentCommits(cwd, GIT_CONTEXT_DEFAULTS.recentCommitsContextCount),
-        stashCount: getStashCount(cwd),
-        aheadBehind: getAheadBehind(cwd),
-        remoteUrl: getRemoteUrl(cwd),
-    };
+    const [branch, remoteBranch, status, recentCommits, stashCount, aheadBehind, remoteUrl] = await Promise.all([
+        getBranch(cwd),
+        getRemoteBranch(cwd),
+        getStatus(cwd),
+        getRecentCommits(cwd, GIT_CONTEXT_DEFAULTS.recentCommitsContextCount),
+        getStashCount(cwd),
+        getAheadBehind(cwd),
+        getRemoteUrl(cwd),
+    ]);
+    return { isRepo: true, branch, remoteBranch, status, recentCommits, stashCount, aheadBehind, remoteUrl };
 }
 export function gitInfoToContext(info) {
     if (!info.isRepo)