@senoldogann/context-manager 0.2.0 → 0.3.0

package/README.md

@@ -4,6 +4,8 @@
 
 **Node.js wrapper for Cognitive Codebase Matrix (CCM)** - Enables AI agents to understand and navigate your codebase with surgical precision.
 
+**v0.2.1** fixes UTF-8 indexing crashes, stale Codex MCP entries, interrupted binary downloads, and missing cross-file class/import usages.
+
 [![npm](https://img.shields.io/npm/v/@senoldogann/context-manager?color=orange)](https://www.npmjs.com/package/@senoldogann/context-manager)
 [![MCP](https://img.shields.io/badge/MCP-Compatible-blue)](https://modelcontextprotocol.io/)
 [![Rust](https://img.shields.io/badge/Built%20With-Rust-orange.svg)](https://www.rust-lang.org/)
@@ -45,6 +47,8 @@ npx @senoldogann/context-manager mcp
 
 If the wrapper is healthy, the query command should return code context and the MCP process should stay open waiting for stdio messages.
 
+The first index is complete; subsequent runs are incremental and process only added, changed, renamed, or deleted files. An unchanged project returns a clean no-op.
+
 ---
 
 ## 📖 What is CCM?
@@ -67,6 +71,7 @@ The npm wrapper downloads pre-built binaries and passes commands through:
 | `npx @senoldogann/context-manager index --path <dir>` | Index a project |
 | `npx @senoldogann/context-manager query --text "..."` | Search codebase |
 | `npx @senoldogann/context-manager mcp` | Run MCP server directly |
+| `npx @senoldogann/context-manager doctor --path <dir>` | Diagnose config and index health |
 | `npx @senoldogann/context-manager eval --tasks <file>` | Run evaluation tasks |
 
 ### Supported Hosts
@@ -138,6 +143,10 @@ CCM_EMBED_DATA_FILES=0
 
 # Binary checksum verification (0 = enforce, 1 = bypass)
 CCM_ALLOW_UNVERIFIED_BINARIES=0
+
+# Optional binary download tuning
+CCM_DOWNLOAD_TIMEOUT_MS=120000
+CCM_DOWNLOAD_ATTEMPTS=3
 ```
 
 Advanced overrides:
@@ -167,16 +176,27 @@ Once configured, ask your AI agent:
 This package handles:
 
 1. OS/architecture detection
-2. Binary download from GitHub Releases
+2. Resumable, retrying compressed binary download from GitHub Releases
 3. Global persistence in `~/.ccm`
 
+For a manual maintainer release, run the commands from this `npm/` directory:
+
+```bash
+npm test
+npm pack --dry-run
+npm publish --access public --provenance
+```
+
+Running `npm publish` from the repository root fails because the root intentionally has no `package.json`.
+
 ### ✅ Release Reliability
 
 - GitHub Releases publish platform binaries plus `checksums.txt`
 - The npm wrapper verifies checksums before using downloaded binaries
+- Interrupted downloads resume from their partial file and use a bounded timeout/retry policy
 - Redirects are restricted to approved GitHub release hosts
 - Release builds run for Linux, macOS, and Windows before assets are attached
-- npm publication is a manual step from `npm/` after the GitHub Release assets are attached
+- Codex configuration is updated directly and atomically, even when the `codex` wrapper is broken
 - The same smoke path is documented here and in the main repository README
 
 ### ✅ Binary Integrity
@@ -197,6 +217,15 @@ Enable `CCM_EMBED_DATA_FILES=1` to include them in semantic search.
 
 ## 📝 Changelog
 
+### v0.2.1
+- ✅ UTF-8-safe semantic chunking prevents panics on Turkish, Finnish, and emoji content
+- ✅ Cross-file imports, constructors, and type annotations contribute to usage and impact analysis
+- ✅ `get_context` returns the enclosing function/class instead of only a leaf assignment
+- ✅ Incremental `diff_context` includes staged, unstaged, and untracked worktree files
+- ✅ Compressed release binaries, download resume/retry/timeout, Linux ARM64 detection
+- ✅ Codex MCP entries are repaired and enabled without depending on the Codex CLI binary
+- ✅ Release tags run tests, lint, npm tests, indexing, and golden tasks v3 before publishing assets
+
 ### v0.1.31
 - ✅ `index_project` is idempotent again and ignores CCM's own generated index files
 - ✅ `search_code` falls back cleanly when embeddings are disabled

package/bin/ccm.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 
-const { spawn, spawnSync } = require('child_process');
+const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
 const https = require('https');
 const crypto = require('crypto');
+const zlib = require('zlib');
+const { pipeline } = require('stream/promises');
 
 function resolvePackageVersion() {
     if (process.env.CCM_BINARY_VERSION && process.env.CCM_BINARY_VERSION.trim() !== '') {
@@ -33,16 +35,15 @@ const VERSION = resolvePackageVersion();
 const REPO = 'senoldogann/LLM-Context-Manager';
 const BIN_DIR = path.join(os.homedir(), '.ccm', 'bin');
 const CHECKSUMS_FILE = 'checksums.txt';
+const DOWNLOAD_TIMEOUT_MS = positiveInteger(process.env.CCM_DOWNLOAD_TIMEOUT_MS, 120_000);
+const DOWNLOAD_ATTEMPTS = positiveInteger(process.env.CCM_DOWNLOAD_ATTEMPTS, 3);
 let checksumCache = null;
 
 const MCP_SERVER_NAME = 'context-manager';
 const MCP_COMMAND = 'npx';
 const MCP_ARGS = ['-y', `@senoldogann/context-manager@${VERSION}`, 'mcp'];
 const MCP_ENV = {
-    RUST_LOG: 'info',
-    CCM_PROJECT_ROOT: process.cwd(),
-    CCM_ALLOWED_ROOTS: process.cwd(),
-    CCM_REQUIRE_ALLOWED_ROOTS: '1'
+    RUST_LOG: 'info'
 };
 const ALLOWED_REDIRECT_HOSTS = new Set([
     'github.com',
@@ -50,6 +51,11 @@ const ALLOWED_REDIRECT_HOSTS = new Set([
     'release-assets.githubusercontent.com'
 ]);
 
+function positiveInteger(raw, fallback) {
+    const value = Number(raw);
+    return Number.isSafeInteger(value) && value > 0 ? value : fallback;
+}
+
 function allowUnverifiedBinaries() {
     const raw = process.env.CCM_ALLOW_UNVERIFIED_BINARIES || process.env.CCM_SKIP_CHECKSUM || '';
     return ['1', 'true', 'yes'].includes(raw.toLowerCase());
@@ -156,82 +162,92 @@ function writeJsonAtomic(configPath, value) {
 }
 
 function installCodexConfig() {
-    const listResult = spawnSync('codex', ['mcp', 'list', '--json'], {
-        encoding: 'utf8'
-    });
-
-    if (listResult.error) {
-        return false;
-    }
-
-    if (listResult.status !== 0) {
-        console.warn(`[CCM] Codex MCP inspection failed: ${listResult.stderr.trim()}`);
-        return false;
-    }
-
-    let existingServers = [];
-    try {
-        existingServers = JSON.parse(listResult.stdout);
-    } catch (error) {
-        console.warn('[CCM] Could not parse Codex MCP list output.');
+    const codexDirectory = path.join(os.homedir(), '.codex');
+    if (!fs.existsSync(codexDirectory)) {
         return false;
     }
+    const configPath = path.join(codexDirectory, 'config.toml');
+    installCodexTomlConfig(configPath, process.cwd(), VERSION);
+    console.log('[CCM] ✓ Successfully updated: ~/.codex/config.toml');
+    return true;
+}
 
-    const existing = existingServers.find((server) => server.name === MCP_SERVER_NAME);
-    if (existing) {
-        console.log('[CCM] Codex MCP entry already exists; leaving it unchanged.');
-        return true;
+function installCodexTomlConfig(configPath, projectRoot, version) {
+    let content = '';
+    if (fs.existsSync(configPath)) {
+        content = fs.readFileSync(configPath, 'utf8');
+        fs.copyFileSync(configPath, `${configPath}.bak`);
     }
 
-    const addArgs = [
-        'mcp',
-        'add',
-        MCP_SERVER_NAME,
-        '--env',
-        'RUST_LOG=info',
-        '--env',
-        `CCM_PROJECT_ROOT=${process.cwd()}`,
-        '--env',
-        `CCM_ALLOWED_ROOTS=${process.cwd()}`,
-        '--env',
-        'CCM_REQUIRE_ALLOWED_ROOTS=1',
-        '--',
-        MCP_COMMAND,
-        ...MCP_ARGS
-    ];
-    const addResult = spawnSync('codex', addArgs, {
-        encoding: 'utf8'
-    });
-
-    if (addResult.status !== 0) {
-        console.warn(`[CCM] Codex MCP install failed: ${addResult.stderr.trim()}`);
-        return false;
+    const sectionPrefix = `mcp_servers.${MCP_SERVER_NAME}`;
+    const lines = content.split(/\r?\n/);
+    const preserved = [];
+    let removing = false;
+    for (const line of lines) {
+        const header = line.trim().match(/^\[([^\]]+)\]$/);
+        if (header) {
+            removing = header[1] === sectionPrefix || header[1].startsWith(`${sectionPrefix}.`);
+        }
+        if (!removing) {
+            preserved.push(line);
+        }
     }
 
-    console.log('[CCM] ✓ Successfully updated: ~/.codex/config.toml');
-    return true;
+    const quote = (value) => JSON.stringify(String(value));
+    const block = [
+        `[${sectionPrefix}]`,
+        `command = ${quote(MCP_COMMAND)}`,
+        `args = [${['-y', `@senoldogann/context-manager@${version}`, 'mcp'].map(quote).join(', ')}]`,
+        'enabled = true',
+        '',
+        `[${sectionPrefix}.env]`,
+        `RUST_LOG = ${quote('info')}`,
+        `CCM_PROJECT_ROOT = ${quote(projectRoot)}`,
+        `CCM_ALLOWED_ROOTS = ${quote(projectRoot)}`,
+        `CCM_REQUIRE_ALLOWED_ROOTS = ${quote('1')}`
+    ].join('\n');
+
+    const next = `${preserved.join('\n').trimEnd()}\n\n${block}\n`.replace(/^\n+/, '');
+    writeTextAtomic(configPath, next);
 }
 
 function createUniqueTmpPath(binPath) {
     return `${binPath}.${process.pid}.${Date.now()}.tmp`;
 }
 
+function writeTextAtomic(filePath, content) {
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        fs.writeFileSync(tempPath, content, { encoding: 'utf8', mode: 0o600 });
+        fs.renameSync(tempPath, filePath);
+    } catch (error) {
+        if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+        throw error;
+    }
+}
+
 async function getBinaryFor(commandName) {
     const platform = os.platform();
     const arch = os.arch();
 
-    let target = '';
+    let target;
     if (platform === 'darwin') {
-        target = arch === 'arm64' ? 'aarch64-apple-darwin' : 'x86_64-apple-darwin';
+        if (arch === 'arm64') target = 'aarch64-apple-darwin';
+        if (arch === 'x64') target = 'x86_64-apple-darwin';
     } else if (platform === 'linux') {
-        target = 'x86_64-unknown-linux-gnu';
+        if (arch === 'arm64') target = 'aarch64-unknown-linux-gnu';
+        if (arch === 'x64') target = 'x86_64-unknown-linux-gnu';
     } else if (platform === 'win32') {
-        target = 'x86_64-pc-windows-msvc.exe';
+        if (arch === 'x64') target = 'x86_64-pc-windows-msvc.exe';
+    }
+    if (!target) {
+        throw new Error(`Unsupported platform: ${platform}/${arch}`);
     }
 
     const binFilename = `${commandName}-v${VERSION}-${target}`;
     const binPath = path.join(BIN_DIR, binFilename);
     const remoteFilename = `${commandName}-${target}`;
+    const compressedFilename = `${remoteFilename}.gz`;
 
     // If file exists, ensure it is executable
     if (fs.existsSync(binPath)) {
@@ -249,12 +265,29 @@ async function getBinaryFor(commandName) {
         fs.mkdirSync(BIN_DIR, { recursive: true });
     }
 
-    const url = `https://github.com/${REPO}/releases/download/v${VERSION}/${commandName}-${target}`;
     const tmpPath = createUniqueTmpPath(binPath);
+    const compressedPath = `${binPath}.gz.download`;
+    const rawPath = `${binPath}.download`;
 
     try {
-        await downloadFile(url, tmpPath);
-        await verifyChecksum(tmpPath, [remoteFilename, binFilename]);
+        const compressedUrl =
+            `https://github.com/${REPO}/releases/download/v${VERSION}/${compressedFilename}`;
+        try {
+            await downloadFileWithRetry(compressedUrl, compressedPath);
+            await verifyChecksum(compressedPath, [compressedFilename]);
+            await extractGzip(compressedPath, tmpPath);
+            fs.unlinkSync(compressedPath);
+        } catch (error) {
+            if (error.statusCode !== 404) {
+                throw error;
+            }
+            if (fs.existsSync(compressedPath)) fs.unlinkSync(compressedPath);
+            const rawUrl =
+                `https://github.com/${REPO}/releases/download/v${VERSION}/${remoteFilename}`;
+            await downloadFileWithRetry(rawUrl, rawPath);
+            await verifyChecksum(rawPath, [remoteFilename, binFilename]);
+            fs.renameSync(rawPath, tmpPath);
+        }
         fs.chmodSync(tmpPath, '755');
         if (fs.existsSync(binPath)) {
             fs.unlinkSync(tmpPath);
@@ -263,12 +296,24 @@ async function getBinaryFor(commandName) {
         fs.renameSync(tmpPath, binPath);
     } catch (err) {
         if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath);
+        if (/checksum|gzip|header|unexpected end/i.test(err.message || '')) {
+            if (fs.existsSync(compressedPath)) fs.unlinkSync(compressedPath);
+            if (fs.existsSync(rawPath)) fs.unlinkSync(rawPath);
+        }
         throw err;
     }
 
     return binPath;
 }
 
+async function extractGzip(source, destination) {
+    await pipeline(
+        fs.createReadStream(source),
+        zlib.createGunzip(),
+        fs.createWriteStream(destination)
+    );
+}
+
 async function getBinary() {
     // Detect which tool to run
     let commandName = 'ccm-cli';
@@ -287,50 +332,87 @@ async function getBinary() {
     return await getBinaryFor(commandName);
 }
 
-function downloadFile(url, dest) {
+function downloadFile(url, dest, redirectsRemaining = 5) {
     return new Promise((resolve, reject) => {
         fs.mkdirSync(path.dirname(dest), { recursive: true });
-        https.get(url, (response) => {
+        const existingBytes = fs.existsSync(dest) ? fs.statSync(dest).size : 0;
+        const headers = existingBytes > 0 ? { Range: `bytes=${existingBytes}-` } : {};
+        const request = https.get(url, { headers }, (response) => {
             if (response.statusCode === 302 || response.statusCode === 301) {
+                response.resume();
+                if (redirectsRemaining <= 0) {
+                    return reject(new Error('Too many redirects while downloading binary'));
+                }
                 try {
                     const redirectUrl = resolveRedirectUrl(url, response.headers.location);
-                    return downloadFile(redirectUrl, dest).then(resolve).catch(reject);
+                    return downloadFile(redirectUrl, dest, redirectsRemaining - 1)
+                        .then(resolve)
+                        .catch(reject);
                 } catch (error) {
                     return reject(error);
                 }
             }
-            if (response.statusCode !== 200) {
-                return reject(new Error(`Failed to download: ${response.statusCode}`));
+            if (response.statusCode === 416 && existingBytes > 0) {
+                response.resume();
+                return resolve();
             }
-            const file = fs.createWriteStream(dest);
-            response.pipe(file);
-            file.on('finish', () => {
-                file.close(resolve);
-            });
-            file.on('error', (err) => {
-                fs.unlink(dest, () => { });
-                reject(err);
-            });
-        }).on('error', (err) => {
-            fs.unlink(dest, () => { });
+            if (response.statusCode !== 200 && response.statusCode !== 206) {
+                response.resume();
+                const error = new Error(`Failed to download: ${response.statusCode}`);
+                error.statusCode = response.statusCode;
+                return reject(error);
+            }
+            const append = response.statusCode === 206 && existingBytes > 0;
+            const file = fs.createWriteStream(dest, { flags: append ? 'a' : 'w' });
+            pipeline(response, file).then(resolve).catch(reject);
+        });
+        request.setTimeout(DOWNLOAD_TIMEOUT_MS, () => {
+            request.destroy(new Error(`Download timed out after ${DOWNLOAD_TIMEOUT_MS}ms`));
+        });
+        request.on('error', (err) => {
             reject(err);
         });
     });
 }
 
-function downloadText(url) {
+async function downloadFileWithRetry(url, dest, attempts = DOWNLOAD_ATTEMPTS) {
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+            await downloadFile(url, dest);
+            return;
+        } catch (error) {
+            lastError = error;
+            if (error.statusCode === 404 || attempt === attempts) break;
+            console.warn(`[CCM] Download interrupted; retrying (${attempt}/${attempts})...`);
+            await new Promise((resolve) => setTimeout(resolve, attempt * 500));
+        }
+    }
+    throw lastError;
+}
+
+function downloadText(url, redirectsRemaining = 5) {
     return new Promise((resolve, reject) => {
-        https.get(url, (response) => {
+        const request = https.get(url, (response) => {
             if (response.statusCode === 302 || response.statusCode === 301) {
+                response.resume();
+                if (redirectsRemaining <= 0) {
+                    return reject(new Error('Too many redirects while downloading checksums'));
+                }
                 try {
                     const redirectUrl = resolveRedirectUrl(url, response.headers.location);
-                    return downloadText(redirectUrl).then(resolve).catch(reject);
+                    return downloadText(redirectUrl, redirectsRemaining - 1)
+                        .then(resolve)
+                        .catch(reject);
                 } catch (error) {
                     return reject(error);
                 }
             }
             if (response.statusCode !== 200) {
-                return reject(new Error(`Failed to download: ${response.statusCode}`));
+                response.resume();
+                const error = new Error(`Failed to download: ${response.statusCode}`);
+                error.statusCode = response.statusCode;
+                return reject(error);
             }
             let data = '';
             response.setEncoding('utf8');
@@ -338,7 +420,11 @@ function downloadText(url) {
                 data += chunk;
             });
             response.on('end', () => resolve(data));
-        }).on('error', reject);
+        });
+        request.setTimeout(DOWNLOAD_TIMEOUT_MS, () => {
+            request.destroy(new Error(`Download timed out after ${DOWNLOAD_TIMEOUT_MS}ms`));
+        });
+        request.on('error', reject);
     });
 }
 
@@ -453,6 +539,8 @@ if (require.main === module) {
 module.exports = {
     MCP_ARGS,
     MCP_ENV,
+    extractGzip,
+    installCodexTomlConfig,
     installJsonConfig,
     parseChecksums,
     resolveRedirectUrl,

package/package.json

@@ -1,13 +1,20 @@
 {
     "name": "@senoldogann/context-manager",
-    "version": "0.2.0",
+    "version": "0.3.0",
     "description": "LLM Context Manager MCP Server & CLI wrapper using npx",
-    "repository": "https://github.com/senoldogann/LLM-Context-Manager",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/senoldogann/LLM-Context-Manager.git"
+    },
     "homepage": "https://github.com/senoldogann/LLM-Context-Manager",
     "bugs": {
         "url": "https://github.com/senoldogann/LLM-Context-Manager/issues"
     },
     "main": "bin/ccm.js",
+    "files": [
+        "bin",
+        "README.md"
+    ],
     "bin": {
         "ccm-cli": "bin/ccm.js",
         "ccm-mcp": "bin/ccm.js"

package/test/installer.test.js

@@ -1,69 +0,0 @@
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const test = require('node:test');
-
-const {
-    MCP_ARGS,
-    MCP_ENV,
-    installJsonConfig,
-    writeJsonAtomic
-} = require('../bin/ccm.js');
-
-function tempConfig() {
-    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'ccm-installer-'));
-    return {
-        directory,
-        configPath: path.join(directory, 'mcp.json')
-    };
-}
-
-test('installer merges MCP config and preserves existing settings', () => {
-    const { configPath } = tempConfig();
-    fs.writeFileSync(
-        configPath,
-        JSON.stringify({ theme: 'dark', mcpServers: { existing: { command: 'safe' } } })
-    );
-
-    const changed = installJsonConfig(configPath, {
-        command: 'npx',
-        args: MCP_ARGS,
-        env: MCP_ENV
-    });
-
-    assert.equal(changed, true);
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    assert.equal(config.theme, 'dark');
-    assert.equal(config.mcpServers.existing.command, 'safe');
-    assert.equal(config.mcpServers['context-manager'].env.CCM_REQUIRE_ALLOWED_ROOTS, '1');
-    assert.ok(fs.existsSync(`${configPath}.bak`));
-});
-
-test('installer never overwrites malformed JSON', () => {
-    const { configPath } = tempConfig();
-    const malformed = '{"mcpServers":';
-    fs.writeFileSync(configPath, malformed);
-
-    assert.throws(
-        () => installJsonConfig(configPath, { command: 'npx', args: [], env: {} }),
-        /Could not parse/
-    );
-    assert.equal(fs.readFileSync(configPath, 'utf8'), malformed);
-    assert.equal(fs.readFileSync(`${configPath}.bak`, 'utf8'), malformed);
-});
-
-test('atomic writer leaves valid JSON and no temporary file', () => {
-    const { directory, configPath } = tempConfig();
-    writeJsonAtomic(configPath, { ok: true });
-
-    assert.deepEqual(JSON.parse(fs.readFileSync(configPath, 'utf8')), { ok: true });
-    assert.deepEqual(fs.readdirSync(directory), ['mcp.json']);
-});
-
-test('generated MCP command pins package version and narrows project access', () => {
-    assert.match(MCP_ARGS[1], /^@senoldogann\/context-manager@\d+\.\d+\.\d+$/);
-    assert.equal(MCP_ENV.CCM_REQUIRE_ALLOWED_ROOTS, '1');
-    assert.equal(MCP_ENV.CCM_ALLOWED_ROOTS, process.cwd());
-    assert.equal(MCP_ENV.CCM_PROJECT_ROOT, process.cwd());
-});