icopilot 2.2.0

package/dist/context/memory.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { PersistentMemory } from './persistent-memory.js';
+import { TeamMemory } from './team-memory.js';
+const MAX_MEMORY_BYTES = 16 * 1024;
+function readMemory(file) {
+    try {
+        if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+            return null;
+        const text = fs.readFileSync(file, 'utf8').slice(0, MAX_MEMORY_BYTES).trim();
+        return text || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function loadMemoryBlock(cwd) {
+    const project = readMemory(path.join(cwd, '.icopilot', 'memory.md'));
+    const team = readTeamMemory(cwd);
+    const global = readMemory(path.join(os.homedir(), '.icopilot', 'memory.md'));
+    const persistent = readPersistentMemory(cwd);
+    const sections = [];
+    if (project)
+        sections.push(`## Project memory\n${project}`);
+    if (team)
+        sections.push(team);
+    if (global)
+        sections.push(`## Global memory\n${global}`);
+    if (persistent)
+        sections.push(persistent);
+    return sections.length ? sections.join('\n\n') : null;
+}
+function readPersistentMemory(cwd) {
+    try {
+        const memory = new PersistentMemory();
+        memory.load(memory.getProjectId(cwd));
+        const rendered = memory.render().slice(0, MAX_MEMORY_BYTES).trim();
+        return rendered || null;
+    }
+    catch {
+        return null;
+    }
+}
+function readTeamMemory(cwd) {
+    try {
+        const memory = new TeamMemory();
+        memory.load(cwd);
+        const rendered = memory.render().slice(0, MAX_MEMORY_BYTES).trim();
+        return rendered || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/context/persistent-memory.js

@@ -0,0 +1,104 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export class PersistentMemory {
+    storePath;
+    entries = new Map();
+    constructor(storePath = path.join(os.homedir(), '.icopilot', 'memory')) {
+        this.storePath = resolveStorePath(storePath);
+    }
+    load(projectId) {
+        this.entries.clear();
+        const filePath = this.filePath(projectId);
+        try {
+            if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile())
+                return;
+            const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            if (!Array.isArray(parsed))
+                return;
+            for (const item of parsed) {
+                const entry = parseMemoryEntry(item);
+                if (!entry)
+                    continue;
+                this.entries.set(entry.key, entry);
+            }
+        }
+        catch {
+            this.entries.clear();
+        }
+    }
+    save(projectId) {
+        fs.mkdirSync(this.storePath, { recursive: true });
+        const filePath = this.filePath(projectId);
+        const payload = JSON.stringify(this.recall(), null, 2);
+        fs.writeFileSync(filePath, `${payload}\n`, 'utf8');
+    }
+    remember(key, value, source = 'user') {
+        const normalizedKey = key.trim();
+        const normalizedValue = value.trim();
+        if (!normalizedKey || !normalizedValue)
+            return;
+        const existing = this.entries.get(normalizedKey);
+        this.entries.set(normalizedKey, {
+            key: normalizedKey,
+            value: normalizedValue,
+            addedAt: existing?.addedAt ?? new Date().toISOString(),
+            source,
+        });
+    }
+    forget(key) {
+        return this.entries.delete(key.trim());
+    }
+    recall(query) {
+        const entries = [...this.entries.values()]
+            .map((entry) => ({ ...entry }))
+            .sort((a, b) => a.key.localeCompare(b.key));
+        const normalizedQuery = query?.trim().toLowerCase();
+        if (!normalizedQuery)
+            return entries;
+        return entries.filter((entry) => entry.key.toLowerCase().includes(normalizedQuery) ||
+            entry.value.toLowerCase().includes(normalizedQuery));
+    }
+    render() {
+        const entries = this.recall();
+        if (entries.length === 0)
+            return '';
+        return [
+            '## Persistent project memory',
+            ...entries.map((entry) => `- ${entry.key}: ${entry.value}`),
+        ].join('\n');
+    }
+    getProjectId(cwd) {
+        const normalized = path.resolve(cwd);
+        const stable = process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+        return crypto.createHash('sha256').update(stable).digest('hex');
+    }
+    filePath(projectId) {
+        return path.join(this.storePath, `${projectId}.json`);
+    }
+}
+function parseMemoryEntry(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const entry = value;
+    if (typeof entry.key !== 'string' ||
+        typeof entry.value !== 'string' ||
+        typeof entry.addedAt !== 'string' ||
+        (entry.source !== 'user' && entry.source !== 'auto')) {
+        return null;
+    }
+    return {
+        key: entry.key,
+        value: entry.value,
+        addedAt: entry.addedAt,
+        source: entry.source,
+    };
+}
+function resolveStorePath(storePath) {
+    if (storePath === '~')
+        return os.homedir();
+    if (/^~[\\/]/.test(storePath))
+        return path.join(os.homedir(), storePath.slice(2));
+    return path.resolve(storePath);
+}

package/dist/context/pinned.js

@@ -0,0 +1,96 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { countTokensSync } from '../util/tokens.js';
+export class PinnedContext {
+    files;
+    constructor(files = []) {
+        this.files = [...files];
+    }
+    add(filePath, cwd) {
+        const resolvedPath = path.resolve(cwd, filePath);
+        try {
+            if (!fs.statSync(resolvedPath).isFile())
+                return null;
+            const content = fs.readFileSync(resolvedPath, 'utf8');
+            const pinnedFile = {
+                path: resolvedPath,
+                addedAt: new Date().toISOString(),
+                tokens: countTokensSync(content),
+            };
+            const existingIndex = this.files.findIndex((file) => file.path === resolvedPath);
+            if (existingIndex >= 0) {
+                this.files[existingIndex] = pinnedFile;
+            }
+            else {
+                this.files.push(pinnedFile);
+            }
+            return pinnedFile;
+        }
+        catch {
+            return null;
+        }
+    }
+    remove(filePath) {
+        const normalizedTarget = path.normalize(filePath);
+        const nextFiles = this.files.filter((file) => path.normalize(file.path) !== normalizedTarget);
+        const removed = nextFiles.length !== this.files.length;
+        this.files = nextFiles;
+        return removed;
+    }
+    list() {
+        return [...this.files];
+    }
+    clear() {
+        const count = this.files.length;
+        this.files = [];
+        return count;
+    }
+    render() {
+        if (!this.files.length)
+            return '';
+        const parts = ['### Pinned context files'];
+        for (const file of this.files) {
+            parts.push('');
+            parts.push(`#### ${file.path}`);
+            try {
+                const content = fs.readFileSync(file.path, 'utf8');
+                const language = path.extname(file.path).replace(/^\./, '');
+                parts.push(`\`\`\`${language}`);
+                parts.push(content);
+                parts.push('```');
+            }
+            catch {
+                parts.push('_[error: unable to read file]_');
+            }
+        }
+        return parts.join('\n');
+    }
+    totalTokens() {
+        return this.files.reduce((total, file) => total + file.tokens, 0);
+    }
+    toJSON() {
+        return this.list();
+    }
+    static fromJSON(data) {
+        if (!Array.isArray(data))
+            return new PinnedContext();
+        const files = data.flatMap((entry) => {
+            if (!entry || typeof entry !== 'object')
+                return [];
+            const candidate = entry;
+            if (typeof candidate.path !== 'string' ||
+                typeof candidate.addedAt !== 'string' ||
+                typeof candidate.tokens !== 'number') {
+                return [];
+            }
+            return [
+                {
+                    path: candidate.path,
+                    addedAt: candidate.addedAt,
+                    tokens: candidate.tokens,
+                },
+            ];
+        });
+        return new PinnedContext(files);
+    }
+}

package/dist/context/priority.js

@@ -0,0 +1,150 @@
+const PINNED_BONUS = 100;
+const RECENTLY_MENTIONED_BONUS = 50;
+const KEYWORD_OVERLAP_BONUS = 30;
+const RECENTLY_MODIFIED_BONUS = 20;
+const SMALL_FILE_BONUS = 10;
+const TEAM_MEMORY_BONUS = 15;
+const DEPENDENCY_PROXIMITY_BONUS = 25;
+const SMALL_SOURCE_TOKEN_LIMIT = 400;
+export class PriorityScorer {
+    score(sources, query) {
+        const queryKeywords = extractKeywords(query);
+        return sources
+            .map((source) => this.scoreSource(source, queryKeywords))
+            .sort(compareScoredSources);
+    }
+    selectWithinBudget(scored, tokenBudget) {
+        const selected = [];
+        let usedTokens = 0;
+        for (const source of scored) {
+            const pinned = isPinnedSource(source);
+            const nextTokens = usedTokens + source.tokens;
+            if (!pinned && nextTokens > tokenBudget)
+                continue;
+            selected.push(source);
+            usedTokens = nextTokens;
+        }
+        return selected;
+    }
+    scoreSource(source, queryKeywords) {
+        let score = 0;
+        const reasons = [];
+        if (isPinnedSource(source)) {
+            score += PINNED_BONUS;
+            reasons.push('pinned source');
+        }
+        if (hasTruthyFlag(source.metadata, ['recentlyMentioned', 'mentionedRecently', 'recentMention'])) {
+            score += RECENTLY_MENTIONED_BONUS;
+            reasons.push('recently mentioned in conversation');
+        }
+        if (hasKeywordOverlap(source, queryKeywords)) {
+            score += KEYWORD_OVERLAP_BONUS;
+            reasons.push('query keyword overlap');
+        }
+        if (isRecentlyModified(source)) {
+            score += RECENTLY_MODIFIED_BONUS;
+            reasons.push('recently modified');
+        }
+        if (source.tokens > 0 && source.tokens <= SMALL_SOURCE_TOKEN_LIMIT) {
+            score += SMALL_FILE_BONUS;
+            reasons.push('small source bonus');
+        }
+        if (source.type === 'team') {
+            score += TEAM_MEMORY_BONUS;
+            reasons.push('team memory');
+        }
+        if (hasDependencyProximity(source.metadata)) {
+            score += DEPENDENCY_PROXIMITY_BONUS;
+            reasons.push('dependency proximity');
+        }
+        return {
+            ...source,
+            score,
+            reasons,
+        };
+    }
+}
+export function buildContextWindow(sources, query, budget) {
+    const scorer = new PriorityScorer();
+    const scored = scorer.score(sources, query);
+    const selected = scorer.selectWithinBudget(scored, budget);
+    return selected
+        .map((source) => [
+        `### [${source.type}] ${source.id}`,
+        `score: ${source.score}`,
+        `reasons: ${source.reasons.join(', ') || 'none'}`,
+        source.content,
+    ].join('\n'))
+        .join('\n\n');
+}
+function compareScoredSources(left, right) {
+    return right.score - left.score || left.tokens - right.tokens || left.id.localeCompare(right.id);
+}
+function isPinnedSource(source) {
+    return source.type === 'pinned' || hasTruthyFlag(source.metadata, ['pinned', 'alwaysInclude']);
+}
+function isRecentlyModified(source) {
+    if (source.type === 'git')
+        return true;
+    return (hasTruthyFlag(source.metadata, ['recentlyModified', 'gitModified']) ||
+        isFreshTimestamp(source.metadata?.updatedAt));
+}
+function hasKeywordOverlap(source, queryKeywords) {
+    if (queryKeywords.size === 0)
+        return false;
+    const sourceKeywords = extractKeywords([
+        source.id,
+        source.content,
+        ...collectTextMetadata(source.metadata),
+        ...collectKeywordMetadata(source.metadata),
+    ].join(' '));
+    for (const keyword of queryKeywords) {
+        if (sourceKeywords.has(keyword))
+            return true;
+    }
+    return false;
+}
+function hasDependencyProximity(metadata) {
+    if (!metadata)
+        return false;
+    if (hasTruthyFlag(metadata, ['dependencyProximity', 'nearDependency']))
+        return true;
+    const distance = metadata.dependencyDistance;
+    return (typeof distance === 'number' && Number.isFinite(distance) && distance >= 0 && distance <= 2);
+}
+function hasTruthyFlag(metadata, keys) {
+    if (!metadata)
+        return false;
+    return keys.some((key) => Boolean(metadata[key]));
+}
+function isFreshTimestamp(value) {
+    if (typeof value !== 'string')
+        return false;
+    const timestamp = Date.parse(value);
+    if (Number.isNaN(timestamp))
+        return false;
+    return Date.now() - timestamp <= 7 * 24 * 60 * 60 * 1000;
+}
+function extractKeywords(text) {
+    return new Set(text
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/i)
+        .map((part) => part.trim())
+        .filter((part) => part.length >= 3));
+}
+function collectTextMetadata(metadata) {
+    if (!metadata)
+        return [];
+    const values = [];
+    for (const key of ['path', 'title', 'summary', 'module', 'dependency']) {
+        const value = metadata[key];
+        if (typeof value === 'string' && value.trim())
+            values.push(value);
+    }
+    return values;
+}
+function collectKeywordMetadata(metadata) {
+    if (!metadata || !Array.isArray(metadata.keywords))
+        return [];
+    return metadata.keywords.filter((value) => typeof value === 'string');
+}

package/dist/context/read-only.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from '../config.js';
+const readOnlyFiles = new Set();
+export function addReadOnly(filePath) {
+    const resolvedPath = path.resolve(config.cwd, filePath);
+    if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isFile()) {
+        throw new Error(`file not found: ${resolvedPath}`);
+    }
+    readOnlyFiles.add(path.normalize(resolvedPath));
+    return resolvedPath;
+}
+export function removeReadOnly(filePath) {
+    return readOnlyFiles.delete(path.normalize(path.resolve(config.cwd, filePath)));
+}
+export function isReadOnly(filePath) {
+    return readOnlyFiles.has(path.normalize(path.resolve(config.cwd, filePath)));
+}
+export function getReadOnlyFiles() {
+    return [...readOnlyFiles].sort((left, right) => left.localeCompare(right));
+}
+export function getReadOnlyContext() {
+    const files = getReadOnlyFiles();
+    if (!files.length)
+        return '';
+    const parts = [
+        '### Read-only context files',
+        '',
+        'These files are available for context only. Do not modify them.',
+    ];
+    for (const file of files) {
+        parts.push('', `#### ${file} (read-only)`);
+        try {
+            const content = fs.readFileSync(file, 'utf8');
+            const language = path.extname(file).replace(/^\./, '');
+            parts.push(`\`\`\`${language}`);
+            parts.push(content);
+            parts.push('```');
+        }
+        catch {
+            parts.push('_[error: unable to read file]_');
+        }
+    }
+    return parts.join('\n');
+}
+export function clearReadOnly() {
+    readOnlyFiles.clear();
+}