@neurcode-ai/cli 0.9.28 → 0.9.29

package/dist/commands/plan.js

@@ -319,6 +319,29 @@ function resolveSnapshotMaxBytes(mode) {
         return envOverride;
     return mode === 'full' ? 0 : 256 * 1024;
 }
+function resolveSnapshotBatchSize(mode) {
+    const envOverride = parsePositiveInt(process.env.NEURCODE_PLAN_SNAPSHOT_BATCH_SIZE);
+    if (typeof envOverride === 'number' && envOverride > 0) {
+        return Math.min(100, Math.max(1, envOverride));
+    }
+    return mode === 'full' ? 30 : 20;
+}
+function resolveSnapshotBatchTimeoutMs(singleRequestTimeoutMs, mode) {
+    const envOverride = parsePositiveInt(process.env.NEURCODE_PLAN_SNAPSHOT_BATCH_TIMEOUT_MS);
+    if (typeof envOverride === 'number' && envOverride > 0)
+        return envOverride;
+    const multiplier = mode === 'full' ? 5 : 4;
+    return Math.max(singleRequestTimeoutMs * multiplier, 12000);
+}
+function isBatchSnapshotEndpointUnsupported(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    return (message.includes('status 404') ||
+        message.includes('not found') ||
+        message.includes('not_found') ||
+        message.includes('method not allowed'));
+}
 function getSnapshotManifestPath(projectRoot) {
     return (0, path_1.join)(projectRoot, '.neurcode', 'snapshot-manifest.json');
 }
@@ -390,6 +413,7 @@ function emitCachedPlanHit(input) {
             sessionId: input.response.sessionId || null,
             projectId: input.projectId || null,
             timestamp: input.response.timestamp,
+            telemetry: input.response.telemetry,
             message: persistedPlan
                 ? `Using ${input.mode === 'near' ? 'near-' : ''}cached plan`
                 : 'Plan generated but could not be persisted (missing planId)',
@@ -1088,29 +1112,56 @@ async function planCommand(intent, options) {
         const snapshotMaxFiles = resolveSnapshotMaxFiles(snapshotMode, options.snapshotMaxFiles);
         const snapshotBudgetMs = resolveSnapshotBudgetMs(snapshotMode, options.snapshotBudgetMs);
         const snapshotMaxBytes = resolveSnapshotMaxBytes(snapshotMode);
+        let snapshotSummary;
         if (isReadOnlyAnalysis) {
             console.log(chalk.dim('\n🔎 Analysis mode: skipping pre-flight file snapshots'));
+            snapshotSummary = {
+                mode: snapshotMode,
+                attempted: 0,
+                processed: 0,
+                saved: 0,
+                failed: 0,
+                skippedUnchanged: 0,
+                skippedMissing: 0,
+                skippedLarge: 0,
+                skippedBudget: 0,
+                capped: 0,
+                usedBatchApi: false,
+                batchFallbackToSingle: false,
+                durationMs: 0,
+            };
         }
         else if (snapshotMode === 'off') {
             console.log(chalk.dim('\n⚡ Snapshot capture disabled (snapshot mode: off)'));
+            snapshotSummary = {
+                mode: snapshotMode,
+                attempted: 0,
+                processed: 0,
+                saved: 0,
+                failed: 0,
+                skippedUnchanged: 0,
+                skippedMissing: 0,
+                skippedLarge: 0,
+                skippedBudget: 0,
+                capped: 0,
+                usedBatchApi: false,
+                batchFallbackToSingle: false,
+                durationMs: 0,
+            };
         }
         else if (modifyFiles.length > 0) {
+            const snapshotStartedAt = Date.now();
             const snapshotCandidates = modifyFiles.slice(0, snapshotMaxFiles);
             const cappedCount = Math.max(0, modifyFiles.length - snapshotCandidates.length);
-            const snapshotConcurrency = Math.min(16, Math.max(1, parsePositiveInt(process.env.NEURCODE_PLAN_SNAPSHOT_CONCURRENCY) ?? (snapshotMode === 'full' ? 8 : 6)));
             const snapshotTimeoutMs = Math.max(1000, parsePositiveInt(process.env.NEURCODE_PLAN_SNAPSHOT_TIMEOUT_MS) ?? (snapshotMode === 'full' ? 15000 : 8000));
+            const snapshotConcurrency = Math.min(16, Math.max(1, parsePositiveInt(process.env.NEURCODE_PLAN_SNAPSHOT_CONCURRENCY) ?? (snapshotMode === 'full' ? 8 : 6)));
+            const snapshotBatchSize = resolveSnapshotBatchSize(snapshotMode);
+            const snapshotBatchTimeoutMs = resolveSnapshotBatchTimeoutMs(snapshotTimeoutMs, snapshotMode);
             const deadline = snapshotBudgetMs > 0 ? Date.now() + snapshotBudgetMs : 0;
             const forceResnapshot = process.env.NEURCODE_PLAN_SNAPSHOT_FORCE === '1';
             console.log(chalk.dim(`\n📸 Capturing pre-flight snapshots for ${snapshotCandidates.length}/${modifyFiles.length} file(s)` +
-                ` [mode=${snapshotMode}, concurrency=${snapshotConcurrency}` +
+                ` [mode=${snapshotMode}, batch=${snapshotBatchSize}, fallback-concurrency=${snapshotConcurrency}` +
                 `${snapshotBudgetMs > 0 ? `, budget=${snapshotBudgetMs}ms` : ', budget=unbounded'}]...`));
-            let snapshotsSaved = 0;
-            let snapshotsFailed = 0;
-            let snapshotsSkippedMissing = 0;
-            let snapshotsSkippedUnchanged = 0;
-            let snapshotsSkippedLarge = 0;
-            let snapshotsProcessed = 0;
-            let budgetExhausted = false;
             const withTimeout = async (promise, timeoutMs) => {
                 return await Promise.race([
                     promise,
@@ -1119,70 +1170,164 @@ async function planCommand(intent, options) {
             };
             const manifest = loadSnapshotManifest(cwd);
             let manifestDirty = false;
-            let cursor = 0;
-            const workers = Array.from({ length: Math.min(snapshotConcurrency, snapshotCandidates.length) }, async () => {
-                while (cursor < snapshotCandidates.length) {
-                    if (budgetExhausted)
-                        break;
-                    if (deadline > 0 && Date.now() >= deadline) {
-                        budgetExhausted = true;
-                        break;
+            const preparedSnapshots = [];
+            let snapshotsProcessed = 0;
+            let snapshotsSaved = 0;
+            let snapshotsFailed = 0;
+            let snapshotsSkippedMissing = 0;
+            let snapshotsSkippedUnchanged = 0;
+            let snapshotsSkippedLarge = 0;
+            let snapshotsSkippedBudget = 0;
+            let usedBatchApi = false;
+            let batchFallbackToSingle = false;
+            for (const current of snapshotCandidates) {
+                if (deadline > 0 && Date.now() >= deadline) {
+                    snapshotsSkippedBudget = snapshotCandidates.length - snapshotsProcessed;
+                    break;
+                }
+                snapshotsProcessed++;
+                try {
+                    const normalizedPath = toUnixPath(current.path);
+                    const filePath = (0, path_1.resolve)(cwd, current.path);
+                    if (!(0, fs_1.existsSync)(filePath)) {
+                        snapshotsSkippedMissing++;
+                        if (process.env.DEBUG) {
+                            console.log(chalk.yellow(`   ⚠️  Skipping ${current.path} (file not found locally)`));
+                        }
+                        continue;
                     }
-                    const current = snapshotCandidates[cursor++];
-                    if (!current)
-                        break;
-                    snapshotsProcessed++;
-                    try {
-                        const normalizedPath = toUnixPath(current.path);
-                        const filePath = (0, path_1.resolve)(cwd, current.path);
-                        if (!(0, fs_1.existsSync)(filePath)) {
-                            snapshotsSkippedMissing++;
-                            if (process.env.DEBUG) {
-                                console.log(chalk.yellow(`   ⚠️  Skipping ${current.path} (file not found locally)`));
-                            }
-                            continue;
+                    const fileContent = (0, fs_1.readFileSync)(filePath, 'utf-8');
+                    const fileSize = Buffer.byteLength(fileContent, 'utf-8');
+                    if (snapshotMaxBytes > 0 && fileSize > snapshotMaxBytes) {
+                        snapshotsSkippedLarge++;
+                        if (process.env.DEBUG) {
+                            console.log(chalk.yellow(`   ⚠️  Skipping ${current.path} (size ${fileSize}B > ${snapshotMaxBytes}B)`));
                         }
-                        const fileContent = (0, fs_1.readFileSync)(filePath, 'utf-8');
-                        const fileSize = Buffer.byteLength(fileContent, 'utf-8');
-                        if (snapshotMaxBytes > 0 && fileSize > snapshotMaxBytes) {
-                            snapshotsSkippedLarge++;
+                        continue;
+                    }
+                    const fileHash = computeSnapshotHash(fileContent);
+                    const previous = manifest.entries[normalizedPath];
+                    if (snapshotMode === 'auto' &&
+                        !forceResnapshot &&
+                        previous &&
+                        previous.sha256 === fileHash &&
+                        previous.size === fileSize) {
+                        snapshotsSkippedUnchanged++;
+                        continue;
+                    }
+                    preparedSnapshots.push({
+                        path: current.path,
+                        normalizedPath,
+                        content: fileContent,
+                        size: fileSize,
+                        sha256: fileHash,
+                    });
+                }
+                catch (error) {
+                    snapshotsFailed++;
+                    if (process.env.DEBUG) {
+                        console.warn(chalk.yellow(`   ⚠️  Failed to prepare snapshot for ${current.path}: ${error instanceof Error ? error.message : 'Unknown error'}`));
+                    }
+                }
+            }
+            const reason = `Pre-Plan Snapshot for "${intent.trim()}"`;
+            const markSnapshotSaved = (snapshot, snapshotAt) => {
+                snapshotsSaved++;
+                manifest.entries[snapshot.normalizedPath] = {
+                    sha256: snapshot.sha256,
+                    size: snapshot.size,
+                    snapshotAt: snapshotAt || new Date().toISOString(),
+                };
+                manifestDirty = true;
+            };
+            let pendingFallbackSnapshots = [];
+            if (preparedSnapshots.length > 0) {
+                try {
+                    usedBatchApi = true;
+                    for (let idx = 0; idx < preparedSnapshots.length; idx += snapshotBatchSize) {
+                        if (deadline > 0 && Date.now() >= deadline) {
+                            const remaining = preparedSnapshots.length - idx;
+                            snapshotsSkippedBudget += Math.max(0, remaining);
+                            break;
+                        }
+                        const chunk = preparedSnapshots.slice(idx, idx + snapshotBatchSize);
+                        const result = await withTimeout(client.saveFileVersionsBatch(chunk.map((snapshot) => ({
+                            filePath: snapshot.path,
+                            fileContent: snapshot.content,
+                            changeType: 'modify',
+                            linesAdded: 0,
+                            linesRemoved: 0,
+                        })), finalProjectId, reason), snapshotBatchTimeoutMs);
+                        const chunkByPath = new Map();
+                        for (const snapshot of chunk) {
+                            chunkByPath.set(snapshot.path, snapshot);
+                        }
+                        for (const saved of result.saved || []) {
+                            const prepared = chunkByPath.get(saved.filePath);
+                            if (!prepared)
+                                continue;
+                            markSnapshotSaved(prepared, saved.version?.createdAt);
+                            chunkByPath.delete(saved.filePath);
+                        }
+                        for (const failed of result.failed || []) {
+                            if (chunkByPath.has(failed.filePath)) {
+                                chunkByPath.delete(failed.filePath);
+                            }
+                            snapshotsFailed++;
                             if (process.env.DEBUG) {
-                                console.log(chalk.yellow(`   ⚠️  Skipping ${current.path} (size ${fileSize}B > ${snapshotMaxBytes}B)`));
+                                console.warn(chalk.yellow(`   ⚠️  Failed to save snapshot for ${failed.filePath}: ${failed.error}`));
                             }
-                            continue;
                         }
-                        const fileHash = computeSnapshotHash(fileContent);
-                        const previous = manifest.entries[normalizedPath];
-                        if (snapshotMode === 'auto' &&
-                            !forceResnapshot &&
-                            previous &&
-                            previous.sha256 === fileHash &&
-                            previous.size === fileSize) {
-                            snapshotsSkippedUnchanged++;
-                            continue;
+                        // Any residual paths were not explicitly reported by API; preserve via fallback.
+                        if (chunkByPath.size > 0) {
+                            pendingFallbackSnapshots.push(...chunkByPath.values());
                         }
-                        const reason = `Pre-Plan Snapshot for "${intent.trim()}"`;
-                        await withTimeout(client.saveFileVersion(current.path, fileContent, finalProjectId, reason, 'modify', 0, 0), snapshotTimeoutMs);
-                        snapshotsSaved++;
-                        manifest.entries[normalizedPath] = {
-                            sha256: fileHash,
-                            size: fileSize,
-                            snapshotAt: new Date().toISOString(),
-                        };
-                        manifestDirty = true;
-                        if (process.env.DEBUG) {
-                            console.log(chalk.green(`   ✓ Snapshot saved: ${current.path}`));
+                    }
+                }
+                catch (error) {
+                    // Backward compatibility: old API versions won't have save-batch endpoint.
+                    if (isBatchSnapshotEndpointUnsupported(error)) {
+                        batchFallbackToSingle = true;
+                        pendingFallbackSnapshots = [...preparedSnapshots];
+                        if (process.env.DEBUG || !options.json) {
+                            console.log(chalk.dim('   Batch snapshot endpoint unavailable; falling back to single-file snapshot uploads.'));
                         }
                     }
-                    catch (error) {
-                        snapshotsFailed++;
+                    else {
+                        snapshotsFailed += preparedSnapshots.length;
                         if (process.env.DEBUG) {
-                            console.warn(chalk.yellow(`   ⚠️  Failed to save snapshot for ${current.path}: ${error instanceof Error ? error.message : 'Unknown error'}`));
+                            console.warn(chalk.yellow(`   ⚠️  Batch snapshot upload failed: ${error instanceof Error ? error.message : 'Unknown error'}`));
                         }
                     }
                 }
-            });
-            await Promise.all(workers);
+            }
+            if (pendingFallbackSnapshots.length > 0) {
+                let fallbackCursor = 0;
+                const fallbackWorkers = Array.from({ length: Math.min(snapshotConcurrency, pendingFallbackSnapshots.length) }, async () => {
+                    while (true) {
+                        const index = fallbackCursor++;
+                        if (index >= pendingFallbackSnapshots.length) {
+                            return;
+                        }
+                        const snapshot = pendingFallbackSnapshots[index];
+                        if (deadline > 0 && Date.now() >= deadline) {
+                            snapshotsSkippedBudget++;
+                            continue;
+                        }
+                        try {
+                            await withTimeout(client.saveFileVersion(snapshot.path, snapshot.content, finalProjectId, reason, 'modify', 0, 0), snapshotTimeoutMs);
+                            markSnapshotSaved(snapshot);
+                        }
+                        catch (error) {
+                            snapshotsFailed++;
+                            if (process.env.DEBUG) {
+                                console.warn(chalk.yellow(`   ⚠️  Failed to save snapshot for ${snapshot.path}: ${error instanceof Error ? error.message : 'Unknown error'}`));
+                            }
+                        }
+                    }
+                });
+                await Promise.all(fallbackWorkers);
+            }
             if (manifestDirty) {
                 try {
                     manifest.updatedAt = new Date().toISOString();
@@ -1194,7 +1339,6 @@ async function planCommand(intent, options) {
                     }
                 }
             }
-            const snapshotsSkippedBudget = Math.max(0, snapshotCandidates.length - snapshotsProcessed);
             if (snapshotsSaved > 0) {
                 console.log(chalk.green(`\n✅ ${snapshotsSaved} pre-flight snapshot(s) saved successfully`));
                 console.log(chalk.dim('   You can revert these files using: neurcode revert <filePath> --to-version <version>'));
@@ -1221,10 +1365,42 @@ async function planCommand(intent, options) {
             if (snapshotsSkippedBudget > 0) {
                 console.log(chalk.dim(`   ${snapshotsSkippedBudget} file(s) deferred by snapshot budget`));
             }
-            if (budgetExhausted && process.env.DEBUG) {
-                console.log(chalk.dim('   Snapshot budget exhausted before processing all candidates.'));
+            if (usedBatchApi) {
+                console.log(chalk.dim(`   Snapshot transport: batch${batchFallbackToSingle ? ' (with single-file fallback)' : ''}`));
             }
             console.log('');
+            snapshotSummary = {
+                mode: snapshotMode,
+                attempted: snapshotCandidates.length,
+                processed: snapshotsProcessed,
+                saved: snapshotsSaved,
+                failed: snapshotsFailed,
+                skippedUnchanged: snapshotsSkippedUnchanged,
+                skippedMissing: snapshotsSkippedMissing,
+                skippedLarge: snapshotsSkippedLarge,
+                skippedBudget: snapshotsSkippedBudget,
+                capped: cappedCount,
+                usedBatchApi,
+                batchFallbackToSingle,
+                durationMs: Date.now() - snapshotStartedAt,
+            };
+        }
+        else {
+            snapshotSummary = {
+                mode: snapshotMode,
+                attempted: 0,
+                processed: 0,
+                saved: 0,
+                failed: 0,
+                skippedUnchanged: 0,
+                skippedMissing: 0,
+                skippedLarge: 0,
+                skippedBudget: 0,
+                capped: 0,
+                usedBatchApi: false,
+                batchFallbackToSingle: false,
+                durationMs: 0,
+            };
         }
         // Step 3: Post-Generation Hallucination Check (DEEP SCAN)
         // Scan ALL plan content for phantom packages - not just summaries, but full proposed code
@@ -1369,6 +1545,8 @@ async function planCommand(intent, options) {
                     sessionId: response.sessionId || null,
                     projectId: finalProjectId || null,
                     timestamp: response.timestamp,
+                    telemetry: response.telemetry,
+                    snapshot: snapshotSummary,
                     message: missingPlanMessage,
                     plan: response.plan,
                 });
@@ -1415,6 +1593,8 @@ async function planCommand(intent, options) {
                 sessionId: response.sessionId || null,
                 projectId: finalProjectId || null,
                 timestamp: response.timestamp,
+                telemetry: response.telemetry,
+                snapshot: snapshotSummary,
                 message: 'Plan generated and persisted',
                 plan: response.plan,
             });