codeep 3.3.3 → 3.4.1

package/dist/utils/userProfile.js

@@ -23,8 +23,10 @@
  * provider+model combos in config.json, see config/index.ts). Different
  * concept, different storage, different command (`/me` vs `/profile`).
  */
-import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, statSync, openSync, readSync, closeSync } from 'fs';
 import { join, dirname } from 'path';
+import { StringDecoder } from 'string_decoder';
+import { isSafeProjectWriteTarget, leadsOutsideProject, writeProjectFile } from './projectPaths.js';
 import { homedir } from 'os';
 import { config } from '../config/index.js';
 /** Max bytes read from each profile file — keeps the prompt budget bounded. */
@@ -50,15 +52,40 @@ export function globalLearnedProfilePath() {
 export function projectLearnedProfilePath(workspaceRoot) {
     return join(workspaceRoot, '.codeep', 'profile.learned.md');
 }
-/** Read + trim a profile file, capped. Returns '' when missing/empty/broken. */
-function readProfile(path) {
+/**
+ * Read + trim a profile file, capped. Returns '' when missing/empty/broken.
+ * A project's profile files can come with a cloned repo, so for those
+ * (`projectRoot` given) a link out of the project is not followed — the
+ * profile rides every system prompt — and only a regular file is read, so a
+ * link to /dev/zero cannot hang the run.
+ */
+function readProfile(path, projectRoot) {
     try {
         if (!existsSync(path))
             return '';
-        let content = readFileSync(path, 'utf-8');
-        if (content.length > MAX_PROFILE_BYTES)
-            content = content.slice(0, MAX_PROFILE_BYTES);
-        return content.trim();
+        if (projectRoot && leadsOutsideProject(path, projectRoot))
+            return '';
+        const stat = statSync(path, { throwIfNoEntry: false });
+        if (stat && !stat.isFile())
+            return '';
+        if (!stat || stat.size <= MAX_PROFILE_BYTES) {
+            return readFileSync(path, 'utf-8').slice(0, MAX_PROFILE_BYTES).trim();
+        }
+        const fd = openSync(path, 'r');
+        try {
+            const buf = Buffer.alloc(MAX_PROFILE_BYTES);
+            let read = 0;
+            while (read < MAX_PROFILE_BYTES) {
+                const n = readSync(fd, buf, read, MAX_PROFILE_BYTES - read, read);
+                if (n === 0)
+                    break;
+                read += n;
+            }
+            return new StringDecoder('utf8').write(buf.subarray(0, read)).trim();
+        }
+        finally {
+            closeSync(fd);
+        }
     }
     catch {
         return '';
@@ -76,7 +103,7 @@ export function loadUserProfilePrompt(workspaceRoot) {
     if (global)
         sections.push(global);
     if (workspaceRoot) {
-        const project = readProfile(projectProfilePath(workspaceRoot));
+        const project = readProfile(projectProfilePath(workspaceRoot), workspaceRoot);
         if (project)
             sections.push(project);
     }
@@ -87,7 +114,7 @@ export function loadUserProfilePrompt(workspaceRoot) {
     if (learnedGlobal)
         sections.push(learnedGlobal);
     if (workspaceRoot) {
-        const learnedProject = readProfile(projectLearnedProfilePath(workspaceRoot));
+        const learnedProject = readProfile(projectLearnedProfilePath(workspaceRoot), workspaceRoot);
         if (learnedProject)
             sections.push(learnedProject);
     }
@@ -165,8 +192,13 @@ export function scaffoldProfile(scope, workspaceRoot) {
     if (existsSync(path))
         return { path, created: false };
     try {
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, scope === 'global' ? GLOBAL_TEMPLATE : PROJECT_TEMPLATE, 'utf-8');
+        if (scope === 'project' && workspaceRoot) {
+            writeProjectFile(workspaceRoot, path, PROJECT_TEMPLATE);
+        }
+        else {
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, GLOBAL_TEMPLATE, 'utf-8');
+        }
         return { path, created: true };
     }
     catch {
@@ -196,9 +228,9 @@ export function formatProfileView(workspaceRoot) {
     }
     lines.push('');
     const globalRaw = readProfile(globalProfilePath());
-    const projectRaw = workspaceRoot ? readProfile(projectProfilePath(workspaceRoot)) : '';
+    const projectRaw = workspaceRoot ? readProfile(projectProfilePath(workspaceRoot), workspaceRoot) : '';
     const learnedGlobalRaw = readProfile(globalLearnedProfilePath());
-    const learnedProjectRaw = workspaceRoot ? readProfile(projectLearnedProfilePath(workspaceRoot)) : '';
+    const learnedProjectRaw = workspaceRoot ? readProfile(projectLearnedProfilePath(workspaceRoot), workspaceRoot) : '';
     if (!globalRaw && !projectRaw && !learnedGlobalRaw && !learnedProjectRaw) {
         lines.push('No profile yet. Run `/me init` to scaffold a global template (or `/me init project` for this project), then edit the file. Or let Codeep build one for you with `/me learn on`.');
     }
@@ -270,7 +302,8 @@ export async function updateLearnedProfile(history, scope = 'global', workspaceR
             .map((m) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${String(m.content).replace(/\s+/g, ' ').slice(0, 600)}`)
             .join('\n')
             .slice(0, 24000);
-        const existingFacts = parseFactBullets(readProfile(targetPath)).join('\n');
+        const projectRoot = scope === 'project' ? workspaceRoot : undefined;
+        const existingFacts = parseFactBullets(readProfile(targetPath, projectRoot)).join('\n');
         const system = scope === 'global' ? GLOBAL_LEARN_SYSTEM : PROJECT_LEARN_SYSTEM;
         const user = `EXISTING FACTS:\n${existingFacts || '(none yet)'}\n\nRECENT CONVERSATION:\n${transcript}`;
         const { chat } = await import('../api/index.js');
@@ -285,8 +318,14 @@ export async function updateLearnedProfile(history, scope = 'global', workspaceR
             ? 'What Codeep has learned about me'
             : 'What Codeep has learned about this project';
         const content = `# ${heading}\n\n<!-- Auto-observed from your Codeep sessions. Edit freely, clear with \`/me forget\`, or turn off with \`/me learn off\`. -->\n\n${facts}\n`;
-        mkdirSync(dirname(targetPath), { recursive: true });
-        writeFileSync(targetPath, content, 'utf-8');
+        if (projectRoot) {
+            // Never through a symlinked .codeep/ that came with the repo.
+            writeProjectFile(projectRoot, targetPath, content);
+        }
+        else {
+            mkdirSync(dirname(targetPath), { recursive: true });
+            writeFileSync(targetPath, content, 'utf-8');
+        }
         return { updated: true, facts };
     }
     catch {
@@ -339,6 +378,9 @@ export function clearLearnedProfile(workspaceRoot) {
     ];
     for (const p of paths) {
         if (p && existsSync(p)) {
+            // Through a symlinked .codeep/ the project path would name a file elsewhere.
+            if (workspaceRoot && p !== paths[0] && !isSafeProjectWriteTarget(workspaceRoot, p))
+                continue;
             try {
                 rmSync(p);
                 removed = true;

package/dist/utils/verify.d.ts

@@ -4,6 +4,13 @@
  */
 export interface VerifyResult {
     success: boolean;
+    /**
+     * Set when the check never reached a verdict: its command was refused by the
+     * shell guard, could not be started, timed out, or the project's
+     * dependencies are not installed. `success` is false, but nothing about the
+     * code was learned, so it is neither a pass nor a failure to fix.
+     */
+    notRun?: string;
     type: 'build' | 'test' | 'lint' | 'typecheck';
     command: string;
     output: string;
@@ -24,6 +31,11 @@ export interface VerifyOptions {
     runLint: boolean;
     runTypecheck: boolean;
     timeout: number;
+    /**
+     * Stops the checks when it fires (the run was stopped): a running command
+     * is killed and its check is reported as not run.
+     */
+    signal?: AbortSignal;
 }
 /**
  * Detect project type and available scripts
@@ -38,19 +50,19 @@ export declare function detectProjectScripts(projectRoot: string): {
 /**
  * Run build verification
  */
-export declare function runBuildVerification(projectRoot: string, timeout?: number): Promise<VerifyResult | null>;
+export declare function runBuildVerification(projectRoot: string, timeout?: number, signal?: AbortSignal): Promise<VerifyResult | null>;
 /**
  * Run test verification
  */
-export declare function runTestVerification(projectRoot: string, timeout?: number): Promise<VerifyResult | null>;
+export declare function runTestVerification(projectRoot: string, timeout?: number, signal?: AbortSignal): Promise<VerifyResult | null>;
 /**
  * Run TypeScript type checking
  */
-export declare function runTypecheckVerification(projectRoot: string, timeout?: number): Promise<VerifyResult | null>;
+export declare function runTypecheckVerification(projectRoot: string, timeout?: number, signal?: AbortSignal): Promise<VerifyResult | null>;
 /**
  * Run lint verification
  */
-export declare function runLintVerification(projectRoot: string, timeout?: number): Promise<VerifyResult | null>;
+export declare function runLintVerification(projectRoot: string, timeout?: number, signal?: AbortSignal): Promise<VerifyResult | null>;
 /**
  * Run all verifications
  */
@@ -63,6 +75,14 @@ export declare function formatVerifyResults(results: VerifyResult[]): string;
  * Format errors for agent to fix
  */
 export declare function formatErrorsForAgent(results: VerifyResult[]): string;
+/**
+ * Checks that ran and failed. A check that could not run is not among them.
+ */
+export declare function failedChecks(results: VerifyResult[]): VerifyResult[];
+/**
+ * Checks that could not be carried out (see VerifyResult.notRun).
+ */
+export declare function checksNotRun(results: VerifyResult[]): VerifyResult[];
 /**
  * Check if any verification failed
  */
@@ -73,6 +93,7 @@ export declare function hasVerificationErrors(results: VerifyResult[]): boolean;
 export declare function getVerificationSummary(results: VerifyResult[]): {
     passed: number;
     failed: number;
+    notRun: number;
     total: number;
     errors: number;
 };