@travisennis/acai 0.0.5 → 0.0.7

package/dist/{tools/bash-utils.js → utils/bash.js}

@@ -1,8 +1,9 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
-import { isPathWithinBaseDir } from "./filesystem-utils.js";
+import { isPathWithinAllowedDirs } from "./filesystem/security.js";
 // Validate path arguments to ensure they're within the project
-export function validatePaths(command, baseDir, cwd) {
+export function validatePaths(command, allowedDirs, cwd) {
     // Simple tokenization - split on spaces but respect quotes
     const tokens = [];
     let current = "";
@@ -43,7 +44,7 @@ export function validatePaths(command, baseDir, cwd) {
         // Skip if it's clearly not a path
         if (cleanToken.startsWith("-") ||
             cleanToken.includes("://") ||
-            !cleanToken.includes("/")) {
+            (!cleanToken.includes("/") && cleanToken !== "~")) {
             continue;
         }
         // Skip git commit messages and other special cases
@@ -52,11 +53,16 @@ export function validatePaths(command, baseDir, cwd) {
             continue;
         }
         try {
-            const resolvedPath = path.resolve(cwd, cleanToken);
-            if (!isPathWithinBaseDir(resolvedPath, baseDir)) {
+            // Expand ~ to home directory for proper validation
+            const expandedToken = cleanToken.startsWith("~/") || cleanToken === "~"
+                ? path.join(os.homedir(), cleanToken.slice(1))
+                : cleanToken;
+            const resolvedPath = path.resolve(cwd, expandedToken);
+            // Allow access to explicitly allowed paths
+            if (!isPathWithinAllowedDirs(resolvedPath, allowedDirs)) {
                 return {
                     isValid: false,
-                    error: `Path '${cleanToken}' resolves outside the project directory (${resolvedPath}). All paths must be within ${baseDir}`,
+                    error: `Path '${cleanToken}' resolves outside the allowed directories (${resolvedPath}). All paths must be within ${allowedDirs.join(", ")}`,
                 };
             }
         }
@@ -64,8 +70,12 @@ export function validatePaths(command, baseDir, cwd) {
     }
     return { isValid: true };
 }
-export const resolveCwd = (cwdInput, workingDir) => {
-    const projectRootAbs = path.resolve(workingDir);
+export const resolveCwd = (cwdInput, workingDir, allowedDirs) => {
+    // Determine which directory to use as the base for resolving relative paths
+    // If allowedDirs is provided and non-empty, use the first allowed directory
+    // Otherwise use the workingDir parameter (backward compatibility)
+    const baseDirForResolution = allowedDirs && allowedDirs.length > 0 ? allowedDirs[0] : workingDir;
+    const projectRootAbs = path.resolve(baseDirForResolution);
     let projectRoot = projectRootAbs;
     try {
         projectRoot = fs.realpathSync(projectRootAbs);
@@ -84,10 +94,19 @@ export const resolveCwd = (cwdInput, workingDir) => {
     catch {
         // If the path doesn't exist entirely, validate intended path
     }
-    const rel = path.relative(projectRoot, target);
-    const inside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
-    if (!inside) {
-        throw new Error(`Working directory must be within the project directory: ${projectRoot}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
+    // Check if within allowed directories if provided, otherwise check project root
+    if (allowedDirs && allowedDirs.length > 0) {
+        if (!isPathWithinAllowedDirs(target, allowedDirs)) {
+            throw new Error(`Working directory must be within the allowed directories: ${allowedDirs.join(", ")}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
+        }
+    }
+    else {
+        // Fallback to original behavior: check within project root
+        const rel = path.relative(projectRoot, target);
+        const inside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+        if (!inside) {
+            throw new Error(`Working directory must be within the project directory: ${projectRoot}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
+        }
     }
     // Check existence and that it's a directory
     let stats;

package/dist/utils/{filesystem.d.ts → filesystem/operations.d.ts}

@@ -20,4 +20,4 @@ export declare function isDirectory(filePath: URL | string): Promise<boolean>;
  * @throws Error if directory cannot be cleared or if path is invalid/unsafe
  */
 export declare function clearDirectory(directoryPath: URL | string): Promise<void>;
-//# sourceMappingURL=filesystem.d.ts.map
+//# sourceMappingURL=operations.d.ts.map

package/dist/utils/filesystem/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../source/utils/filesystem/operations.ts"],"names":[],"mappings":"AAIA,wBAAgB,MAAM,CAAC,SAAS,EAAE,GAAG,GAAG,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAS/C;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,GAAG,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAmB1E;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,aAAa,EAAE,GAAG,GAAG,MAAM,GAC1B,OAAO,CAAC,IAAI,CAAC,CAuGf"}

package/dist/utils/filesystem/security.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectConfig } from "../../config.ts";
+export declare function joinWorkingDir(userPath: string, workingDir: string): string;
+export declare function isPathWithinAllowedDirs(requestedPath: string, allowedDirs: string[]): boolean;
+export declare function validatePath(requestedPath: string, allowedDirectory: string | string[], options?: {
+    requireExistence?: boolean;
+    abortSignal?: AbortSignal;
+}): Promise<string>;
+export declare function validateFileNotReadOnly(filePath: string, config: ProjectConfig, workingDir: string): void;
+//# sourceMappingURL=security.d.ts.map

package/dist/utils/filesystem/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../../source/utils/filesystem/security.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAsCrD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK3E;AAoCD,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAIT;AAGD,wBAAsB,YAAY,CAChC,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE,EACnC,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,WAAW,CAAA;CAAO,GACtE,OAAO,CAAC,MAAM,CAAC,CA6HjB;AA8BD,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,MAAM,GACjB,IAAI,CAIN"}

package/dist/{tools/filesystem-utils.js → utils/filesystem/security.js}

@@ -1,4 +1,4 @@
-import { realpathSync } from "node:fs";
+import { realpathSync, statSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -6,6 +6,36 @@ import path from "node:path";
 function normalizePath(p) {
     return path.normalize(p);
 }
+// Resolve symlinks for existing ancestors of a path.
+// Walks up the directory tree until an existing directory is found, resolves its real path,
+// and appends the remaining relative path. Permission errors are treated as non-existence.
+function resolveExistingAncestorSync(filePath) {
+    let current = filePath;
+    while (true) {
+        try {
+            const stats = statSync(current);
+            if (stats.isDirectory()) {
+                const realCurrent = realpathSync(current);
+                const remaining = path.relative(current, filePath);
+                return remaining === ""
+                    ? realCurrent
+                    : path.join(realCurrent, remaining);
+            }
+            // If current exists but is not a directory, move up
+        }
+        catch {
+            // current doesn't exist or we lack permission to stat it
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            // Reached root, cannot resolve further
+            break;
+        }
+        current = parent;
+    }
+    // No existing ancestor found, return original path
+    return filePath;
+}
 // Handle path joining with working directory
 export function joinWorkingDir(userPath, workingDir) {
     if (path.isAbsolute(userPath)) {
@@ -20,7 +50,7 @@ function expandHome(filepath) {
     return filepath;
 }
 // Ensure path is within base directory (handles '.', relative paths, and symlinks)
-export function isPathWithinBaseDir(requestedPath, baseDir) {
+function isPathWithinBaseDir(requestedPath, baseDir) {
     const baseAbs = path.resolve(baseDir);
     let baseReal = baseAbs;
     try {
@@ -37,11 +67,16 @@ export function isPathWithinBaseDir(requestedPath, baseDir) {
         target = realpathSync(abs);
     }
     catch {
-        // If target doesn't fully exist, validate against intended path
+        // If target doesn't fully exist, resolve existing ancestors
+        target = resolveExistingAncestorSync(abs);
     }
     const rel = path.relative(baseReal, target);
     return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
 }
+// Check if path is within any of the allowed directories
+export function isPathWithinAllowedDirs(requestedPath, allowedDirs) {
+    return allowedDirs.some((allowedDir) => isPathWithinBaseDir(requestedPath, allowedDir));
+}
 // Security utilities
 export async function validatePath(requestedPath, allowedDirectory, options = {}) {
     const { requireExistence = true, abortSignal } = options;
@@ -53,27 +88,37 @@ export async function validatePath(requestedPath, allowedDirectory, options = {}
         ? path.resolve(expandedPath)
         : path.resolve(process.cwd(), expandedPath);
     const normalizedRequested = normalizePath(absolute);
-    let normalizedAllowed = normalizePath(path.resolve(allowedDirectory));
-    // Try to resolve real path for allowedDirectory when it exists to handle symlinked roots
-    try {
-        const stats = await fs.stat(normalizedAllowed);
-        if (stats.isDirectory()) {
-            const allowedReal = await fs.realpath(normalizedAllowed);
-            normalizedAllowed = normalizePath(allowedReal);
+    // Handle both single directory and array of directories
+    const allowedDirectories = Array.isArray(allowedDirectory)
+        ? allowedDirectory
+        : [allowedDirectory];
+    // Resolve and normalize all allowed directories
+    const normalizedAllowedDirs = await Promise.all(allowedDirectories.map(async (dir) => {
+        let normalizedDir = normalizePath(path.resolve(dir));
+        // Try to resolve real path for allowedDirectory when it exists to handle symlinked roots
+        try {
+            const stats = await fs.stat(normalizedDir);
+            if (stats.isDirectory()) {
+                const allowedReal = await fs.realpath(normalizedDir);
+                normalizedDir = normalizePath(allowedReal);
+            }
         }
-    }
-    catch (_err) {
-        // If allowedDirectory doesn't exist, keep normalizedAllowed as-is
-    }
-    // Helper to check if a path is within the allowed directory using path.relative
+        catch (_err) {
+            // If allowedDirectory doesn't exist, keep normalizedDir as-is
+        }
+        return normalizedDir;
+    }));
+    // Helper to check if a path is within any allowed directory using path.relative
     const isWithinAllowed = (targetPath) => {
-        const rel = path.relative(normalizedAllowed, targetPath);
-        // Allow the allowed directory itself (rel === "") and any descendant paths
-        return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+        return normalizedAllowedDirs.some((normalizedAllowed) => {
+            const rel = path.relative(normalizedAllowed, targetPath);
+            // Allow the allowed directory itself (rel === "") and any descendant paths
+            return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+        });
     };
-    // Check intended path is within allowed directory
+    // Check intended path is within any allowed directory
     if (!isWithinAllowed(normalizedRequested)) {
-        throw new Error(`Access denied - path outside allowed directories: ${absolute} not in ${allowedDirectory}`);
+        throw new Error(`Access denied - path outside allowed directories: ${absolute} not in any of ${allowedDirectories.join(", ")}`);
     }
     let validatedPath;
     // Try to resolve real path for existing targets to handle symlinks safely
@@ -105,7 +150,11 @@ export async function validatePath(requestedPath, allowedDirectory, options = {}
                 foundValidAncestor = true;
                 break;
             }
-            catch (_err) {
+            catch (err) {
+                // If it's a security denial, rethrow
+                if (err instanceof Error && err.message.startsWith("Access denied")) {
+                    throw err;
+                }
                 // If we reached the filesystem root, break to fallback check
                 const parent = path.dirname(current);
                 if (parent === current) {
@@ -137,3 +186,26 @@ export async function validatePath(requestedPath, allowedDirectory, options = {}
     }
     return validatedPath;
 }
+// Check if a file is read-only based on config
+function isFileReadOnly(filePath, readOnlyFiles, workingDir) {
+    if (readOnlyFiles.length === 0) {
+        return false;
+    }
+    const normalizedFilePath = normalizePath(path.resolve(workingDir, filePath));
+    return readOnlyFiles.some((readOnlyPattern) => {
+        // Handle absolute paths
+        if (path.isAbsolute(readOnlyPattern)) {
+            const normalizedPattern = normalizePath(path.resolve(readOnlyPattern));
+            return normalizedFilePath === normalizedPattern;
+        }
+        // Handle relative paths (relative to working directory)
+        const normalizedRelativePattern = normalizePath(path.resolve(workingDir, readOnlyPattern));
+        return normalizedFilePath === normalizedRelativePattern;
+    });
+}
+// Validate that a file is not read-only before modification
+export function validateFileNotReadOnly(filePath, config, workingDir) {
+    if (isFileReadOnly(filePath, config.readOnlyFiles, workingDir)) {
+        throw new Error(`File is read-only and cannot be modified: ${filePath}`);
+    }
+}

package/dist/utils/funcs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Identity function for tokens that should not be styled (returns the input string as-is).
+ * See [[Theme]] for an example.
+ */
+export declare const id: <T>(value: T) => T;
+//# sourceMappingURL=funcs.d.ts.map

package/dist/utils/funcs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"funcs.d.ts","sourceRoot":"","sources":["../../source/utils/funcs.ts"],"names":[],"mappings":"AACA;;;GAGG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,CAAU,CAAC"}

package/dist/utils/funcs.js

@@ -0,0 +1,6 @@
+//
+/**
+ * Identity function for tokens that should not be styled (returns the input string as-is).
+ * See [[Theme]] for an example.
+ */
+export const id = (value) => value;

package/dist/utils/generators.d.ts

@@ -0,0 +1,3 @@
+export declare function exhaustGenerator<T, TReturn, TNext>(generator: Generator<T, TReturn, TNext>): TReturn;
+export declare function exhaustGenerator<T, TReturn, TNext>(generator: AsyncGenerator<T, TReturn, TNext>): Promise<TReturn>;
+//# sourceMappingURL=generators.d.ts.map

package/dist/utils/generators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generators.d.ts","sourceRoot":"","sources":["../../source/utils/generators.ts"],"names":[],"mappings":"AASA,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAChD,SAAS,EAAE,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,GACtC,OAAO,CAAC;AAGX,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAChD,SAAS,EAAE,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,GAC3C,OAAO,CAAC,OAAO,CAAC,CAAC"}

package/dist/utils/generators.js

@@ -0,0 +1,25 @@
+function isPromiseLike(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.then === "function");
+}
+// biome-ignore lint/style/useNamingConvention: temp
+export function exhaustGenerator(generator) {
+    const firstResult = generator.next();
+    if (isPromiseLike(firstResult)) {
+        const asyncGenerator = generator;
+        return (async () => {
+            let result = await firstResult;
+            while (!result.done) {
+                result = await asyncGenerator.next();
+            }
+            return result.value;
+        })();
+    }
+    const syncGenerator = generator;
+    let result = firstResult;
+    while (!result.done) {
+        result = syncGenerator.next();
+    }
+    return result.value;
+}

package/dist/{tools/git-utils.d.ts → utils/git.d.ts}

@@ -18,4 +18,4 @@ export declare function hasUncommittedChanges(): Promise<boolean>;
  * Get the current git branch name
  */
 export declare function getCurrentBranch(): Promise<string | null>;
-//# sourceMappingURL=git-utils.d.ts.map
+//# sourceMappingURL=git.d.ts.map

package/dist/utils/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../source/utils/git.ts"],"names":[],"mappings":"AAIA,wBAAsB,WAAW;;;;GAyDhC;AAED,wBAAsB,YAAY;;;;;GAmCjC;AAED,eAAO,MAAM,cAAc,QAAqB,OAAO,CAAC,OAAO,CAS7D,CAAC;AAEH;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAY9D;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkB/D"}

package/dist/{tools/git-utils.js → utils/git.js}

@@ -103,9 +103,6 @@ export const inGitDirectory = memoize(async () => {
  * Check if there are uncommitted changes
  */
 export async function hasUncommittedChanges() {
-    if (!(await inGitDirectory())) {
-        return false;
-    }
     try {
         const result = await executeCommand(["git", "status", "--porcelain"], {
             cwd: process.cwd(),
@@ -122,9 +119,6 @@ export async function hasUncommittedChanges() {
  * Get the current git branch name
  */
 export async function getCurrentBranch() {
-    if (!(await inGitDirectory())) {
-        return null;
-    }
     try {
         const result = await executeCommand(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
             cwd: process.cwd(),

package/dist/utils/glob.js

@@ -3,7 +3,7 @@ import { readFile } from "node:fs/promises";
 import path, * as nodePath from "node:path";
 import * as process from "node:process";
 import fg from "fast-glob";
-import { isDirectory, slash, toPath } from "./filesystem.js";
+import { isDirectory, slash, toPath } from "./filesystem/operations.js";
 import { Ignore } from "./ignore.js";
 // Cache for ignore patterns to avoid repeated IO
 const ignoreCache = new Map();

package/dist/utils/iterables.d.ts

@@ -0,0 +1,2 @@
+export declare function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T>;
+//# sourceMappingURL=iterables.d.ts.map

package/dist/utils/iterables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterables.d.ts","sourceRoot":"","sources":["../../source/utils/iterables.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,CAAC,CAQ5E"}

package/dist/utils/iterables.js

@@ -0,0 +1,6 @@
+export function isAsyncIterable(value) {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    return (typeof value[Symbol.asyncIterator] === "function");
+}

package/dist/utils/{zod-utils.d.ts → zod.d.ts}

@@ -1,4 +1,4 @@
 import { ZodType } from "zod";
 export declare function isZodSchema(obj: unknown): obj is ZodType<unknown>;
 export declare function zodToJsonSchema(schema: ZodType<unknown>): Record<string, unknown>;
-//# sourceMappingURL=zod-utils.d.ts.map
+//# sourceMappingURL=zod.d.ts.map

package/dist/utils/zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../source/utils/zod.ts"],"names":[],"mappings":"AAAA,OAAU,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEjC,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,CAEjE;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,GACvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzB"}

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@travisennis/acai",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "An AI assistant for developing software.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "acai": "dist/index.js",
-    "@travisennis/acai": "dist/index.js"
+    "acai": "bin/acai-wrapper.js",
+    "@travisennis/acai": "bin/acai-wrapper.js"
   },
   "files": [
     "dist",
+    "bin",
     "README.md",
     "LICENSE"
   ],
@@ -48,40 +49,39 @@
     "typecheck:staged": "npm run typecheck"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^2.0.25",
-    "@ai-sdk/deepseek": "^1.0.21",
-    "@ai-sdk/google": "^2.0.18",
-    "@ai-sdk/groq": "^2.0.23",
-    "@ai-sdk/openai": "^2.0.46",
-    "@ai-sdk/openai-compatible": "^1.0.20",
+    "@ai-sdk/anthropic": "^2.0.56",
+    "@ai-sdk/deepseek": "^1.0.32",
+    "@ai-sdk/google": "^2.0.46",
+    "@ai-sdk/groq": "^2.0.33",
+    "@ai-sdk/openai": "^2.0.86",
+    "@ai-sdk/openai-compatible": "^1.0.29",
     "@crosscopy/clipboard": "^0.2.8",
-    "@openrouter/ai-sdk-provider": "^1.2.0",
+    "@openrouter/ai-sdk-provider": "^1.5.3",
     "@travisennis/stdlib": "^0.0.14",
-    "ai": "^5.0.64",
+    "ai": "^5.0.113",
     "cheerio": "^1.1.2",
-    "cli-table3": "^0.6.5",
     "diff": "^8.0.2",
     "duck-duck-scrape": "^2.2.7",
     "fast-glob": "^3.3.3",
     "highlight.js": "^11.11.1",
     "jsonrepair": "^3.13.1",
-    "marked": "16.4.0",
-    "p-throttle": "^8.0.0",
+    "marked": "17.0.1",
+    "p-throttle": "^8.1.0",
     "parse5": "^8.0.0",
     "parse5-htmlparser2-tree-adapter": "^8.0.0",
-    "pino": "^10.0.0",
-    "pino-pretty": "^13.1.1",
+    "pino": "^10.1.0",
+    "pino-pretty": "^13.1.3",
     "pino-roll": "^4.0.0",
     "tiktoken": "^1.0.22",
-    "zod": "^4.1.12"
+    "zod": "^4.1.13"
   },
   "devDependencies": {
     "@ai-sdk/provider": "^2.0.0",
-    "@biomejs/biome": "2.2.5",
-    "@commitlint/config-conventional": "^20.0.0",
-    "@types/node": "^24.7.1",
+    "@biomejs/biome": "2.3.8",
+    "@commitlint/config-conventional": "^20.2.0",
+    "@types/node": "^25.0.2",
     "c8": "^10.1.3",
-    "commitlint": "^20.1.0",
+    "commitlint": "^20.2.0",
     "domhandler": "^5.0.3",
     "husky": "^9.1.7",
     "typescript": "^5.9.3"

package/dist/conversation-analyzer.d.ts

@@ -1,11 +0,0 @@
-import { type ModelMessage } from "ai";
-import type { ModelManager } from "./models/manager.ts";
-import type { Terminal } from "./terminal/index.ts";
-import type { TokenTracker } from "./tokens/tracker.ts";
-export declare function analyzeConversation({ modelManager, messages, tokenTracker, }: {
-    modelManager: ModelManager;
-    messages: ModelMessage[];
-    terminal?: Terminal | undefined;
-    tokenTracker: TokenTracker;
-}): Promise<string[]>;
-//# sourceMappingURL=conversation-analyzer.d.ts.map

package/dist/conversation-analyzer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"conversation-analyzer.d.ts","sourceRoot":"","sources":["../source/conversation-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,IAAI,CAAC;AAGrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAyCxD,wBAAsB,mBAAmB,CAAC,EACxC,YAAY,EACZ,QAAQ,EACR,YAAY,GACb,EAAE;IACD,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,YAAY,EAAE,YAAY,CAAC;CAC5B,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA0DpB"}

package/dist/conversation-analyzer.js

@@ -1,88 +0,0 @@
-import { generateText } from "ai";
-import { config } from "./config.js";
-import { createUserMessage } from "./messages.js";
-import { systemPrompt } from "./prompts.js";
-// Modified System Prompt
-const system = async () => `You are an expert analyst reviewing conversations between a coding agent and a software engineer. Your goal is to identify instances where the engineer corrected the agent's approach or understanding in a way that reveals a *generalizable principle* for improving the agent's future behavior across *different* tasks.
-
-**Your Task:**
-1. Analyze the conversation provided.
-2. Identify significant corrections or redirections from the engineer. Ignore minor clarifications or task-specific adjustments.
-3. For each significant correction, infer a *single, concise, broadly applicable, actionable rule* (starting with 'Always' or 'Never') that captures the underlying principle the agent should follow in the future.
-4. Ensure the rule is general enough to be useful in various scenarios, not just the specific context of this conversation.
-5. Provide a brief, illustrative quote or example from the conversation in parentheses after the rule.
-6. List only the inferred rules in Markdown bullet points. Do not include explanations, summaries, or conversational filler.
-
-**Crucially, AVOID generating rules that are:**
-- Overly specific to the files, functions, or variables discussed (e.g., "Always check for null in the 'processUserData' function"). Instead, generalize (e.g., "Always validate data from external sources before processing").
-- Merely restatements of the task requirements.
-- Too narrow to be useful outside the immediate context.
-- Related to minor typos or formatting preferences unless they represent a consistent pattern requested by the user.
-
-**Good General Rule Examples:**
-<examples>
-- Always ask for clarification if the user's request is ambiguous.
-- Never make assumptions about file paths without confirmation.
-- Always follow the user's explicitly stated formatting preferences.
-- Never provide incomplete code snippets without indicating they are partial.
-- Always check for potential null or undefined values before accessing properties.
-</examples>
-
-**Bad Specific Rule Examples (Avoid These):**
-<bad-examples>
-- Always use 'const' instead of 'let' for the 'userId' variable in 'auth.ts'.
-- Never forget to pass the 'config' object to the 'initializeDb' function.
-- Always add a try-catch block around the 'api.fetchData()' call in 'dataService.ts'.
-</bad-examples>
-
-This is the original system prompt the agent operated under:
-<systemPrompt>
-${await systemPrompt()}
-</systemPrompt>`;
-export async function analyzeConversation({ modelManager, messages, tokenTracker, }) {
-    const learnedRules = await config.readCachedLearnedRulesFile();
-    // Modified User Message within analyzeConversation
-    messages.push(createUserMessage([
-        `Analyze this conversation based on the system instructions. Identify points where the user made significant corrections revealing general principles for agent improvement. Infer concise, broadly applicable rules (Always/Never) based *only* on these corrections.
-
-**Key Requirements:**
-- Focus on *generalizable* rules applicable to future, different tasks.
-- Avoid rules tied to the specifics of *this* conversation.
-- Ensure rules don't already exist in <existing-rules>.
-- If no *new, general* rules can be inferred, return an empty list or response.
-- Return *only* the Markdown list of rules, with no preamble or explanation.
-
-<existing-rules>
-${learnedRules}
-</existing-rules>`,
-    ]));
-    const { text, usage } = await generateText({
-        model: modelManager.getModel("conversation-analyzer"),
-        maxOutputTokens: 8192,
-        system: await system(),
-        messages: messages,
-    });
-    tokenTracker.trackUsage("conversation-analyzer", usage);
-    // Trim whitespace and check if the response is effectively empty or just whitespace
-    const potentialRulesText = text.trim();
-    // Basic check to prevent adding empty lines or just formatting
-    if (!potentialRulesText || potentialRulesText.length === 0) {
-        return []; // Return empty array if no valid rules generated
-    }
-    // Split into individual rules, filter out empty lines
-    const potentialRulesList = potentialRulesText
-        .split("\n")
-        .map((rule) => rule.trim())
-        .filter((rule) => rule.length > 0);
-    if (potentialRulesList.length === 0) {
-        return []; // Return empty array if splitting results in no rules
-    }
-    // Further validation could be added here (e.g., check if it starts with '- ', etc.)
-    // before writing to the file.
-    // Append only if there are non-empty potential rules
-    const updatedRules = learnedRules.endsWith("\n") || learnedRules.length === 0
-        ? `${learnedRules}${potentialRulesList.join("\n")}`
-        : `${learnedRules}\n${potentialRulesList.join("\n")}`;
-    await config.writeCachedLearnedRulesFile(updatedRules);
-    return potentialRulesList; // Return the list of rules that were added
-}

package/dist/repl/display-tool-messages.d.ts

@@ -1,4 +0,0 @@
-import type { Terminal } from "../terminal/index.ts";
-import type { Message } from "../tools/types.ts";
-export declare function displayToolMessages(messages: Message[], terminal: Terminal): void;
-//# sourceMappingURL=display-tool-messages.d.ts.map

package/dist/repl/display-tool-messages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"display-tool-messages.d.ts","sourceRoot":"","sources":["../../source/repl/display-tool-messages.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,QAAQ,QAiC1E"}