icopilot 2.2.0

package/dist/context/smart-files.js

@@ -0,0 +1,286 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import simpleGit from 'simple-git';
+import { config } from '../config.js';
+const DEFAULT_MAX_FILES = 10;
+const SMALL_FILE_BYTES = 16 * 1024;
+const DEFAULT_IGNORES = new Set(['.git', 'node_modules', 'dist', 'coverage', '.vitest']);
+const STOP_WORDS = new Set([
+    'a',
+    'an',
+    'and',
+    'by',
+    'file',
+    'find',
+    'for',
+    'from',
+    'in',
+    'of',
+    'on',
+    'or',
+    'relevant',
+    'show',
+    'the',
+    'to',
+    'with',
+]);
+const SHORT_KEYWORDS = new Set(['c', 'go', 'js', 'md', 'py', 'ts']);
+const EXTENSION_KEYWORDS = [
+    { extensions: ['.ts', '.mts', '.cts'], keywords: ['ts', 'typescript', 'type-safe'] },
+    { extensions: ['.tsx'], keywords: ['tsx', 'react', 'component', 'typescript'] },
+    { extensions: ['.js', '.mjs', '.cjs'], keywords: ['js', 'javascript', 'node'] },
+    { extensions: ['.json'], keywords: ['json', 'config', 'configuration', 'manifest'] },
+    { extensions: ['.md'], keywords: ['docs', 'documentation', 'markdown', 'md', 'readme'] },
+    { extensions: ['.yml', '.yaml'], keywords: ['workflow', 'yaml', 'yml', 'config'] },
+];
+export class SmartFileSelector {
+    cwd;
+    constructor(cwd = config.cwd) {
+        this.cwd = cwd;
+    }
+    async selectRelevant(query, options = {}) {
+        const maxFiles = Math.max(1, options.maxFiles ?? DEFAULT_MAX_FILES);
+        const keywords = extractKeywords(query);
+        const normalizedQuery = normalizeForMatch(query);
+        if (!keywords.length && !normalizedQuery) {
+            return [];
+        }
+        const candidates = await collectCandidateFiles(this.cwd, options);
+        if (!candidates.length) {
+            return [];
+        }
+        const recentPaths = options.preferRecent === false ? new Set() : await getRecentPaths(this.cwd);
+        const fallbackRecentPaths = recentPaths.size || options.preferRecent === false
+            ? new Set()
+            : getFallbackRecentPaths(candidates, maxFiles);
+        return candidates
+            .map((candidate) => scoreCandidate(candidate, keywords, normalizedQuery, recentPaths, fallbackRecentPaths))
+            .filter((candidate) => candidate !== null)
+            .sort((left, right) => right.score - left.score || left.path.localeCompare(right.path))
+            .slice(0, maxFiles);
+    }
+}
+async function collectCandidateFiles(cwd, options) {
+    const gitignoreRules = readGitignoreRules(cwd);
+    const matcher = options.filePattern ? createGlobMatcher(options.filePattern) : null;
+    const candidates = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        await Promise.all(entries.map(async (entry) => {
+            const absolutePath = path.join(dir, entry.name);
+            const relativePath = normalizeSlashes(path.relative(cwd, absolutePath));
+            if (!relativePath) {
+                return;
+            }
+            if (shouldIgnore(relativePath, entry.isDirectory(), gitignoreRules)) {
+                return;
+            }
+            if (entry.isDirectory()) {
+                await walk(absolutePath);
+                return;
+            }
+            if (!entry.isFile()) {
+                return;
+            }
+            if (!options.includeTests && isTestFile(relativePath)) {
+                return;
+            }
+            if (matcher && !matcher.test(relativePath)) {
+                return;
+            }
+            try {
+                const stats = await fs.promises.stat(absolutePath);
+                candidates.push({ path: relativePath, size: stats.size, mtimeMs: stats.mtimeMs });
+            }
+            catch {
+                // Ignore unreadable files.
+            }
+        }));
+    }
+    await walk(cwd);
+    return candidates;
+}
+function scoreCandidate(candidate, keywords, normalizedQuery, recentPaths, fallbackRecentPaths) {
+    const normalizedPath = normalizeForMatch(candidate.path);
+    const ext = path.extname(candidate.path).toLowerCase();
+    const fileName = path.basename(candidate.path);
+    const normalizedFileName = normalizeForMatch(fileName);
+    const normalizedBaseName = normalizeForMatch(path.basename(candidate.path, ext));
+    const componentTokens = new Set(splitComponents(candidate.path));
+    const reasons = [];
+    let score = 0;
+    const exactMatchTerms = [normalizedQuery, ...keywords].filter(Boolean);
+    const baseNameTokens = normalizedBaseName.split('-').filter(Boolean);
+    const exactMatch = exactMatchTerms.some((term) => normalizedFileName === term || normalizedBaseName === term) ||
+        (baseNameTokens.length > 0 && baseNameTokens.every((token) => keywords.includes(token)));
+    if (exactMatch) {
+        score += 10;
+        reasons.push('exact filename match');
+    }
+    const matchedPathKeywords = keywords.filter((keyword) => {
+        if (componentTokens.has(keyword)) {
+            return true;
+        }
+        return normalizedPath.includes(keyword);
+    });
+    if (matchedPathKeywords.length) {
+        score += 5;
+        reasons.push(`path component match (${unique(matchedPathKeywords).join(', ')})`);
+    }
+    if (isExtensionRelevant(ext, candidate.path, keywords)) {
+        score += 3;
+        reasons.push(`extension relevance (${ext || 'no extension'})`);
+    }
+    if (recentPaths.has(candidate.path) || fallbackRecentPaths.has(candidate.path)) {
+        score += 2;
+        reasons.push('recently modified');
+    }
+    if (candidate.size <= SMALL_FILE_BYTES) {
+        score += 1;
+        reasons.push('small file bonus');
+    }
+    return score > 0 ? { path: candidate.path, score, reason: reasons.join('; ') } : null;
+}
+async function getRecentPaths(cwd) {
+    try {
+        const git = simpleGit({ baseDir: cwd });
+        const output = await git.raw(['log', '-n', '1', '--name-only', '--format=']);
+        return new Set(output
+            .split(/\r?\n/)
+            .map((line) => normalizeSlashes(line.trim()))
+            .filter(Boolean));
+    }
+    catch {
+        return new Set();
+    }
+}
+function getFallbackRecentPaths(candidates, maxFiles) {
+    const count = Math.min(candidates.length, Math.max(maxFiles, 3));
+    return new Set([...candidates]
+        .sort((left, right) => right.mtimeMs - left.mtimeMs)
+        .slice(0, count)
+        .map((candidate) => candidate.path));
+}
+function readGitignoreRules(cwd) {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+        return [];
+    }
+    try {
+        return fs
+            .readFileSync(gitignorePath, 'utf8')
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith('#'));
+    }
+    catch {
+        return [];
+    }
+}
+function shouldIgnore(relativePath, isDirectory, rules) {
+    if (!relativePath || relativePath.startsWith('..')) {
+        return false;
+    }
+    const normalizedPath = normalizeSlashes(relativePath);
+    const segments = normalizedPath.split('/');
+    if (segments.some((segment) => DEFAULT_IGNORES.has(segment))) {
+        return true;
+    }
+    let ignored = false;
+    for (const rawRule of rules) {
+        const negated = rawRule.startsWith('!');
+        const rule = negated ? rawRule.slice(1) : rawRule;
+        if (!rule) {
+            continue;
+        }
+        if (matchesGitignoreRule(normalizedPath, segments, isDirectory, rule)) {
+            ignored = !negated;
+        }
+    }
+    return ignored;
+}
+function matchesGitignoreRule(normalizedPath, segments, isDirectory, rule) {
+    const normalizedRule = normalizeSlashes(rule).replace(/^\/+/, '');
+    const directoryOnly = normalizedRule.endsWith('/');
+    const bareRule = normalizedRule.replace(/\/+$/, '');
+    if (!bareRule) {
+        return false;
+    }
+    if (directoryOnly && !isDirectory && bareRule === normalizedPath) {
+        return false;
+    }
+    if (!hasGlob(bareRule) && !bareRule.includes('/')) {
+        return segments.includes(bareRule);
+    }
+    if (!hasGlob(bareRule)) {
+        return normalizedPath === bareRule || normalizedPath.startsWith(`${bareRule}/`);
+    }
+    return createGlobMatcher(bareRule).test(normalizedPath);
+}
+function createGlobMatcher(pattern) {
+    const normalizedPattern = normalizeSlashes(pattern).replace(/^\/+/, '');
+    const source = normalizedPattern
+        .replace(/[|\\{}()[\]^$+.]/g, '\\$&')
+        .replace(/\*\*/g, '::DOUBLE_STAR::')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/::DOUBLE_STAR::/g, '.*');
+    return new RegExp(`^${source}$`, 'i');
+}
+function hasGlob(value) {
+    return /[*?[\]]/.test(value);
+}
+function extractKeywords(query) {
+    return unique(query
+        .toLowerCase()
+        .split(/[^a-z0-9.\-_]+/)
+        .map((part) => normalizeForMatch(part))
+        .filter((part) => {
+        if (!part)
+            return false;
+        if (STOP_WORDS.has(part))
+            return false;
+        return part.length > 1 || SHORT_KEYWORDS.has(part);
+    }));
+}
+function isExtensionRelevant(ext, filePath, keywords) {
+    const lowerPath = filePath.toLowerCase();
+    if (keywords.some((keyword) => keyword === ext.replace(/^\./, '') || keyword === lowerPath.split('.').slice(1).join('.'))) {
+        return true;
+    }
+    return EXTENSION_KEYWORDS.some((entry) => {
+        return (entry.extensions.includes(ext) &&
+            entry.keywords.some((keyword) => keywords.includes(normalizeForMatch(keyword))));
+    });
+}
+function isTestFile(filePath) {
+    const normalizedPath = normalizeSlashes(filePath).toLowerCase();
+    return (normalizedPath.includes('/tests/') ||
+        normalizedPath.includes('/__tests__/') ||
+        /(?:^|\/)[^.]+\.(test|spec)\.[^/]+$/.test(normalizedPath));
+}
+function splitComponents(filePath) {
+    return unique(normalizeSlashes(filePath)
+        .toLowerCase()
+        .split(/[/.\-_]+/)
+        .map((part) => part.trim())
+        .filter(Boolean));
+}
+function normalizeForMatch(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function normalizeSlashes(value) {
+    return value.split(path.sep).join('/');
+}
+function unique(values) {
+    return [...new Set(values)];
+}

package/dist/context/team-memory.js

@@ -0,0 +1,156 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const TEAM_MEMORY_FILE = '.icopilot/team-memory.md';
+const FILE_HEADER = `# Team memory
+
+<!-- Shared team memory for conventions, decisions, tips, and warnings. -->
+`;
+export class TeamMemory {
+    filePath = null;
+    entries = [];
+    load(projectRoot) {
+        this.filePath = path.join(projectRoot, '.icopilot', 'team-memory.md');
+        this.entries = readEntries(this.filePath);
+        return this.list();
+    }
+    add(entry) {
+        this.assertLoaded();
+        const normalized = normalizeEntry(entry);
+        this.entries = this.entries.filter((candidate) => candidate.id !== normalized.id);
+        this.entries.push(normalized);
+        this.persist();
+    }
+    remove(id) {
+        this.assertLoaded();
+        const normalizedId = id.trim();
+        if (!normalizedId)
+            return;
+        this.entries = this.entries.filter((entry) => entry.id !== normalizedId);
+        this.persist();
+    }
+    list() {
+        return this.entries.map(cloneEntry);
+    }
+    render() {
+        if (this.entries.length === 0)
+            return '';
+        return [
+            '## Team memory',
+            ...this.entries.map((entry) => {
+                const meta = [entry.category, entry.author?.trim(), entry.date?.trim()].filter((value) => Boolean(value));
+                return `- [${meta.join(' • ')}] ${entry.content}`;
+            }),
+        ].join('\n');
+    }
+    search(query) {
+        const normalized = query.trim().toLowerCase();
+        if (!normalized)
+            return this.list();
+        return this.entries
+            .filter((entry) => [entry.id, entry.category, entry.content, entry.author, entry.date]
+            .filter((value) => typeof value === 'string')
+            .some((value) => value.toLowerCase().includes(normalized)))
+            .map(cloneEntry);
+    }
+    assertLoaded() {
+        if (!this.filePath)
+            throw new Error('Team memory must be loaded before use.');
+    }
+    persist() {
+        if (!this.filePath)
+            return;
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        fs.writeFileSync(this.filePath, serializeEntries(this.entries), 'utf8');
+    }
+}
+function readEntries(filePath) {
+    try {
+        if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile())
+            return [];
+        const text = fs.readFileSync(filePath, 'utf8');
+        return parseEntries(text);
+    }
+    catch {
+        return [];
+    }
+}
+function parseEntries(markdown) {
+    const entries = [];
+    const normalized = markdown.replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (!line.startsWith('## '))
+            continue;
+        const heading = line.slice(3).trim();
+        const bodyLines = [];
+        index += 1;
+        while (index < lines.length && !lines[index].startsWith('## ')) {
+            bodyLines.push(lines[index]);
+            index += 1;
+        }
+        const entry = parseSection(heading, bodyLines.join('\n'));
+        if (entry)
+            entries.push(entry);
+        if (index < lines.length && lines[index].startsWith('## ')) {
+            index -= 1;
+        }
+    }
+    return entries;
+}
+function parseSection(heading, body) {
+    const match = body.trim().match(/^<!--\s*\n?([\s\S]*?)\n?-->\s*([\s\S]*)$/);
+    if (!match)
+        return null;
+    const metadata = parseMetadata(match[1] ?? '');
+    const category = metadata.category;
+    const content = (match[2] ?? '').trim();
+    if (!isCategory(category) || !content)
+        return null;
+    const id = typeof metadata.id === 'string' && metadata.id.trim() ? metadata.id.trim() : heading;
+    if (!id)
+        return null;
+    return normalizeEntry({
+        id,
+        category,
+        content,
+        author: metadata.author,
+        date: metadata.date,
+    });
+}
+function parseMetadata(block) {
+    const metadata = {};
+    for (const line of block.split(/\r?\n/)) {
+        const match = line.match(/^\s*([a-zA-Z][\w-]*)\s*:\s*(.*?)\s*$/);
+        if (!match)
+            continue;
+        metadata[match[1].toLowerCase()] = match[2];
+    }
+    return metadata;
+}
+function serializeEntries(entries) {
+    const blocks = entries.map((entry) => {
+        const metadataLines = [`id: ${entry.id}`, `category: ${entry.category}`];
+        if (entry.author?.trim())
+            metadataLines.push(`author: ${entry.author.trim()}`);
+        if (entry.date?.trim())
+            metadataLines.push(`date: ${entry.date.trim()}`);
+        return [`## ${entry.id}`, '<!--', ...metadataLines, '-->', entry.content.trim()].join('\n');
+    });
+    return `${[FILE_HEADER.trimEnd(), ...blocks].join('\n\n').trimEnd()}\n`;
+}
+function normalizeEntry(entry) {
+    return {
+        id: entry.id.trim(),
+        category: entry.category,
+        content: entry.content.trim(),
+        author: entry.author?.trim() || undefined,
+        date: entry.date?.trim() || undefined,
+    };
+}
+function cloneEntry(entry) {
+    return { ...entry };
+}
+function isCategory(value) {
+    return value === 'convention' || value === 'decision' || value === 'tip' || value === 'warning';
+}

package/dist/extensions/loader.js

@@ -0,0 +1,149 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { theme } from '../ui/theme.js';
+const EXTENSIONS_DIR = path.join('.icopilot', 'extensions');
+const HANDLER_FILE = 'index.js';
+export function discoverExtensions(cwd) {
+    const userRoot = path.join(os.homedir(), EXTENSIONS_DIR);
+    const projectRoot = path.join(cwd, EXTENSIONS_DIR);
+    const discovered = new Map();
+    for (const root of [userRoot, projectRoot]) {
+        for (const extension of discoverExtensionsInRoot(root)) {
+            discovered.set(extension.name.toLowerCase(), extension);
+        }
+    }
+    return [...discovered.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function loadExtensionManifest(extDir) {
+    const manifestPath = path.join(extDir, 'manifest.json');
+    try {
+        const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        return isExtensionManifest(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function listExtensions(cwd) {
+    const extensions = discoverExtensions(cwd);
+    if (extensions.length === 0)
+        return theme.dim('No extensions discovered.\n');
+    const lines = extensions.map((extension) => {
+        const scope = extension.path.startsWith(path.join(cwd, '.icopilot'))
+            ? theme.ok('project')
+            : theme.dim('user');
+        const toolCount = extension.tools?.length ?? 0;
+        const commandCount = extension.commands?.length ?? 0;
+        return `  ${theme.hl(extension.name)} ${theme.dim(`v${extension.version}`)} ${theme.dim(`(${scope})`)} ${extension.description}${theme.dim(` [tools:${toolCount} commands:${commandCount}]`)}`;
+    });
+    return `${theme.brand('Extensions')}\n${lines.join('\n')}\n`;
+}
+export function extensionCommand(args, cwd) {
+    const [subcommandRaw, ...rest] = args;
+    const subcommand = (subcommandRaw || 'list').toLowerCase();
+    switch (subcommand) {
+        case 'list':
+            return listExtensions(cwd);
+        case 'info':
+            return infoExtension(rest.join(' ').trim(), cwd);
+        case 'reload': {
+            const count = discoverExtensions(cwd).length;
+            return theme.ok(`✔ reloaded ${count} extension${count === 1 ? '' : 's'}\n`);
+        }
+        default:
+            return theme.warn('usage: /extension list|info <name>|reload\n');
+    }
+}
+function infoExtension(name, cwd) {
+    if (!name)
+        return theme.warn('usage: /extension info <name>\n');
+    const extension = discoverExtensions(cwd).find((candidate) => candidate.name.localeCompare(name, undefined, { sensitivity: 'accent' }) === 0);
+    if (!extension)
+        return theme.warn(`extension not found: ${name}\n`);
+    const lines = [
+        `${theme.brand('Extension')} ${theme.hl(extension.name)} ${theme.dim(`v${extension.version}`)}`,
+        `  ${extension.description}`,
+        `  ${theme.dim('path:')} ${extension.path}`,
+    ];
+    if ((extension.tools?.length ?? 0) > 0) {
+        lines.push(`  ${theme.ok('tools')}`);
+        for (const tool of extension.tools ?? []) {
+            lines.push(`    ${theme.hl(tool.name)} ${theme.dim('→')} ${tool.description}`);
+        }
+    }
+    if ((extension.commands?.length ?? 0) > 0) {
+        lines.push(`  ${theme.ok('commands')}`);
+        for (const command of extension.commands ?? []) {
+            lines.push(`    ${theme.hl(command.name)} ${theme.dim('→')} ${command.description}`);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+function discoverExtensionsInRoot(root) {
+    if (!fs.existsSync(root))
+        return [];
+    const entries = fs.readdirSync(root, { withFileTypes: true });
+    const discovered = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const extDir = path.join(root, entry.name);
+        const manifest = loadExtensionManifest(extDir);
+        if (!manifest)
+            continue;
+        discovered.push(extendManifest(extDir, manifest));
+    }
+    return discovered;
+}
+function extendManifest(extDir, manifest) {
+    const handler = path.join(extDir, HANDLER_FILE);
+    return {
+        ...manifest,
+        tools: manifest.tools?.map((tool) => ({ ...tool, handler })),
+        commands: manifest.commands?.map((command) => ({ ...command, handler })),
+        path: extDir,
+    };
+}
+function isExtensionManifest(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const manifest = value;
+    return (isNonEmptyString(manifest.name) &&
+        isNonEmptyString(manifest.version) &&
+        isNonEmptyString(manifest.description) &&
+        isToolManifestArray(manifest.tools) &&
+        isCommandManifestArray(manifest.commands));
+}
+function isToolManifestArray(value) {
+    if (value === undefined)
+        return true;
+    if (!Array.isArray(value))
+        return false;
+    return value.every((tool) => {
+        if (!tool || typeof tool !== 'object' || Array.isArray(tool))
+            return false;
+        const entry = tool;
+        return (isNonEmptyString(entry.name) &&
+            isNonEmptyString(entry.description) &&
+            isPlainObject(entry.parameters));
+    });
+}
+function isCommandManifestArray(value) {
+    if (value === undefined)
+        return true;
+    if (!Array.isArray(value))
+        return false;
+    return value.every((command) => {
+        if (!command || typeof command !== 'object' || Array.isArray(command))
+            return false;
+        const entry = command;
+        return isNonEmptyString(entry.name) && isNonEmptyString(entry.description);
+    });
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/extensions/marketplace.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+export class LocalPluginCatalog {
+    file;
+    constructor(file = path.join(os.homedir(), '.icopilot', 'plugins.json')) {
+        this.file = file;
+    }
+    async list() {
+        try {
+            const raw = await fs.readFile(this.file, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return [];
+            return parsed.filter(isPluginEntry);
+        }
+        catch (err) {
+            if (err?.code === 'ENOENT')
+                return [];
+            throw err;
+        }
+    }
+    async search(query) {
+        const q = query.trim().toLowerCase();
+        const entries = await this.list();
+        if (!q)
+            return entries;
+        return entries.filter((entry) => [entry.name, entry.description, entry.install, entry.homepage || '']
+            .join('\n')
+            .toLowerCase()
+            .includes(q));
+    }
+}
+function isPluginEntry(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const entry = value;
+    return (typeof entry.name === 'string' &&
+        typeof entry.description === 'string' &&
+        typeof entry.install === 'string' &&
+        (entry.homepage === undefined || typeof entry.homepage === 'string'));
+}
+let _catalog = new LocalPluginCatalog();
+export function registerPluginCatalog(c) {
+    _catalog = c;
+}
+export function getPluginCatalog() {
+    return _catalog;
+}