pi-advisor-flow 0.2.8 → 0.3.0

package/src/ui.ts

@@ -24,6 +24,18 @@ interface SearchableModelSelectorOptions {
   title: string;
   tui: RenderRequester;
 }
+const stepNumericPreset = (
+  current: number,
+  presets: number[],
+  direction: number
+) => {
+  const values = presets.includes(current)
+    ? presets
+    : [...presets, current].sort((a, b) => a - b);
+  const index = values.indexOf(current);
+  return values[Math.max(0, Math.min(values.length - 1, index + direction))];
+};
+
 interface AdvisorSettingsSelectorOptions {
   effortLevels: string[];
   initial: AdvisorSettings;
@@ -208,6 +220,7 @@ export interface AdvisorSettings {
   toolPolicies?: Record<string, "full" | "summary" | "exclude">;
   toolResultMaxBytes?: number;
   toolResultMaxLines?: number;
+  trackedFileContent?: boolean;
   untrackedContent?: boolean;
 }
 
@@ -235,6 +248,7 @@ type AdvisorSettingsRow =
   | "gitContextMaxChars"
   | "toolPolicies"
   | "outcomeLogging"
+  | "trackedFileContent"
   | "untrackedContent"
   | "save";
 
@@ -259,6 +273,7 @@ const ADVANCED_ROWS: AdvisorSettingsRow[] = [
   "gitContext",
   "gitContextMaxChars",
   "toolPolicies",
+  "trackedFileContent",
   "untrackedContent",
   "outcomeLogging",
 ];
@@ -304,14 +319,24 @@ export class AdvisorSettingsSelector implements Component, Focusable {
     this.editingCustom = false;
     this.editingPolicies = false;
     this.policiesError = undefined;
-    this.options = options;
     // Retain every advanced value even when Simple mode hides its controls.
     this.settings = { ...options.initial };
-    this.contextIndex = Math.max(
-      0,
-      options.presets.findIndex(
-        (preset) => preset.value === this.settings.contextMaxChars
-      )
+    const configuredContext = this.settings.contextMaxChars;
+    const presets = options.presets.some(
+      (preset) => preset.value === configuredContext
+    )
+      ? [...options.presets]
+      : [
+          ...options.presets,
+          {
+            description: "Custom configured value",
+            label: String(configuredContext),
+            value: configuredContext,
+          },
+        ].sort((a, b) => a.value - b.value);
+    this.options = { ...options, presets };
+    this.contextIndex = presets.findIndex(
+      (preset) => preset.value === configuredContext
     );
     this.effortIndex = Math.max(
       0,
@@ -519,6 +544,11 @@ export class AdvisorSettingsSelector implements Component, Focusable {
           : "All tools: full",
         "toolPolicies"
       ),
+      this.row(
+        "Tracked file content",
+        onOff(this.settings.trackedFileContent ?? false),
+        "trackedFileContent"
+      ),
       this.row(
         "Untracked file content",
         onOff(this.settings.untrackedContent ?? false),
@@ -746,6 +776,7 @@ export class AdvisorSettingsSelector implements Component, Focusable {
     tui.requestRender();
   }
 
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one keyboard dispatcher maps each settings row to its bounded adjustment.
   private adjust(direction: number): void {
     switch (this.selectedRowId()) {
       case "simpleMode":
@@ -808,11 +839,14 @@ export class AdvisorSettingsSelector implements Component, Focusable {
         );
         break;
       case "maxCallsPerSession": {
-        const values = [undefined, 0, 1, 2, 3, 5, 10, 25, 50];
-        const index = Math.max(
-          0,
-          values.indexOf(this.settings.maxCallsPerSession)
-        );
+        const current = this.settings.maxCallsPerSession;
+        const numeric = [0, 1, 2, 3, 5, 10, 25, 50];
+        const sorted =
+          current === undefined || numeric.includes(current)
+            ? numeric
+            : [...numeric, current].sort((a, b) => a - b);
+        const values: (number | undefined)[] = [undefined, ...sorted];
+        const index = values.indexOf(current);
         this.settings.maxCallsPerSession =
           values[Math.max(0, Math.min(values.length - 1, index + direction))];
         break;
@@ -842,6 +876,11 @@ export class AdvisorSettingsSelector implements Component, Focusable {
       case "redactSecrets":
         this.settings.redactSecrets = !(this.settings.redactSecrets ?? false);
         break;
+      case "trackedFileContent":
+        this.settings.trackedFileContent = !(
+          this.settings.trackedFileContent ?? false
+        );
+        break;
       case "untrackedContent":
         this.settings.untrackedContent = !(
           this.settings.untrackedContent ?? false
@@ -865,33 +904,27 @@ export class AdvisorSettingsSelector implements Component, Focusable {
         break;
       }
       case "gitContextMaxChars": {
-        const values = [0, 5000, 10_000, 20_000, 50_000, 100_000];
-        const index = Math.max(
-          0,
-          values.indexOf(this.settings.gitContextMaxChars ?? 20_000)
+        this.settings.gitContextMaxChars = stepNumericPreset(
+          this.settings.gitContextMaxChars ?? 20_000,
+          [0, 5000, 10_000, 20_000, 50_000, 100_000],
+          direction
         );
-        this.settings.gitContextMaxChars =
-          values[Math.max(0, Math.min(values.length - 1, index + direction))];
         break;
       }
       case "toolResultMaxLines": {
-        const values = [0, 500, 1000, 2000, 5000, 10_000];
-        const index = Math.max(
-          0,
-          values.indexOf(this.settings.toolResultMaxLines ?? 2000)
+        this.settings.toolResultMaxLines = stepNumericPreset(
+          this.settings.toolResultMaxLines ?? 2000,
+          [0, 500, 1000, 2000, 5000, 10_000],
+          direction
         );
-        this.settings.toolResultMaxLines =
-          values[Math.max(0, Math.min(values.length - 1, index + direction))];
         break;
       }
       case "toolResultMaxBytes": {
-        const values = [0, 10 * 1024, 50 * 1024, 100 * 1024, 500 * 1024];
-        const index = Math.max(
-          0,
-          values.indexOf(this.settings.toolResultMaxBytes ?? 50 * 1024)
+        this.settings.toolResultMaxBytes = stepNumericPreset(
+          this.settings.toolResultMaxBytes ?? 50 * 1024,
+          [0, 10 * 1024, 50 * 1024, 100 * 1024, 500 * 1024],
+          direction
         );
-        this.settings.toolResultMaxBytes =
-          values[Math.max(0, Math.min(values.length - 1, index + direction))];
         break;
       }
       default:

package/src/untracked.ts

@@ -1,15 +1,19 @@
 import { execFileSync } from "node:child_process";
+import { constants } from "node:fs";
 import { lstat, open, realpath } from "node:fs/promises";
 import { isAbsolute, relative, resolve } from "node:path";
 import { redactAndCapText } from "./conversation.js";
 
-export const UNTRACKED_FILE_MAX_BYTES = 8 * 1024;
-export const UNTRACKED_TOTAL_MAX_BYTES = 24 * 1024;
+export const ADVISOR_FILE_MAX_BYTES = 8 * 1024;
+export const ADVISOR_FILES_TOTAL_MAX_BYTES = 24 * 1024;
+export const UNTRACKED_FILE_MAX_BYTES = ADVISOR_FILE_MAX_BYTES;
+export const UNTRACKED_TOTAL_MAX_BYTES = ADVISOR_FILES_TOTAL_MAX_BYTES;
 export interface UntrackedAttachment {
   bytes: number;
   path: string;
   text: string;
 }
+export type TrackedAttachment = UntrackedAttachment;
 
 const PATH_SEGMENTS = /[\\/]/;
 
@@ -32,20 +36,34 @@ const normalizeRequestedPath = (root: string, value: unknown) => {
   return normalizeRelativePath(root, value);
 };
 
+const git = (cwd: string, args: string[]) =>
+  execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 5000,
+    windowsHide: true,
+  });
+
+const repositoryRoot = (cwd: string) => {
+  try {
+    return realpath(git(cwd, ["rev-parse", "--show-toplevel"]).trim());
+  } catch {
+    return Promise.resolve(undefined);
+  }
+};
+
 const untracked = (cwd: string, path: string) => {
-  const output = execFileSync(
-    "git",
-    ["ls-files", "--others", "--exclude-standard", "-z", "--", path],
-    {
-      cwd,
-      encoding: "utf8",
-      maxBuffer: 16 * 1024 * 1024,
-      shell: false,
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 5000,
-      windowsHide: true,
-    }
-  );
+  const output = git(cwd, [
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "-z",
+    "--",
+    path,
+  ]);
   const expected = normalizeRelativePath(cwd, path);
   return output
     .split("\0")
@@ -53,17 +71,86 @@ const untracked = (cwd: string, path: string) => {
     .some((entry) => normalizeRelativePath(cwd, entry) === expected);
 };
 
-/** Returns only exact, permitted untracked regular-file bodies. Refusals are silent. */
-export const readUntrackedFiles = async (
+const tracked = (cwd: string, path: string) => {
+  const output = git(cwd, ["ls-files", "--stage", "-z", "--", path]);
+  const expected = normalizeRelativePath(cwd, path);
+  return output.split("\0").some((entry) => {
+    if (!entry) {
+      return false;
+    }
+    const [metadata, name] = entry.split("\t");
+    return (
+      name &&
+      normalizeRelativePath(cwd, name) === expected &&
+      !metadata.startsWith("160000 ")
+    );
+  });
+};
+
+const isPermitted = (
+  root: string,
+  path: string,
+  kind: "tracked" | "untracked"
+) => (kind === "tracked" ? tracked(root, path) : untracked(root, path));
+
+const readAttachment = async (
+  root: string,
+  normalizedName: string,
+  redact: boolean,
+  available: number
+): Promise<UntrackedAttachment | undefined> => {
+  const absolute = resolve(root, normalizedName);
+  if (!(within(root, absolute) && available > 0)) {
+    return;
+  }
+  const stats = await lstat(absolute);
+  if (stats.isSymbolicLink() || !stats.isFile()) {
+    return;
+  }
+  const resolved = await realpath(absolute);
+  if (!within(root, resolved)) {
+    return;
+  }
+  const flags = constants.O_NOFOLLOW
+    ? // biome-ignore lint/suspicious/noBitwiseOperators: fs.open requires numeric flags for O_NOFOLLOW.
+      constants.O_RDONLY | constants.O_NOFOLLOW
+    : constants.O_RDONLY;
+  const file = await open(resolved, flags);
+  try {
+    const openedStats = await file.stat();
+    if (!openedStats.isFile()) {
+      return;
+    }
+    const buffer = Buffer.alloc(available + 1);
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+    const raw = buffer.subarray(0, bytesRead).toString("utf8");
+    if (raw.includes("\0")) {
+      return;
+    }
+    const text = redactAndCapText(raw, available, redact);
+    return {
+      bytes: Buffer.byteLength(text, "utf8"),
+      path: normalizedName,
+      text,
+    };
+  } finally {
+    await file.close();
+  }
+};
+
+/** Reads exact, permitted regular-file bodies. Refusals are silent. */
+const readFiles = async (
   cwd: string,
   requested: string[],
   enabled: boolean,
-  redact: boolean
+  redact: boolean,
+  kind: "tracked" | "untracked",
+  totalLimit = ADVISOR_FILES_TOTAL_MAX_BYTES
 ): Promise<UntrackedAttachment[]> => {
   if (!(enabled && Array.isArray(requested))) {
     return [];
   }
-  const root = await realpath(cwd).catch(() => undefined);
+  const root = await repositoryRoot(cwd);
   if (!root) {
     return [];
   }
@@ -77,41 +164,24 @@ export const readUntrackedFiles = async (
     }
     unique.add(normalizedName);
     try {
-      const absolute = resolve(root, normalizedName);
-      if (!(within(root, absolute) && untracked(root, normalizedName))) {
+      if (!isPermitted(root, normalizedName, kind)) {
         continue;
       }
+      const available = Math.min(ADVISOR_FILE_MAX_BYTES, totalLimit - total);
+      if (available <= 0) {
+        break;
+      }
       // Sequentially enforce the aggregate disclosure budget.
       // biome-ignore lint/performance/noAwaitInLoops: each accepted file consumes the remaining budget.
-      const stats = await lstat(absolute);
-      if (stats.isSymbolicLink() || !stats.isFile()) {
-        continue;
-      }
-      const resolved = await realpath(absolute);
-      if (!within(root, resolved)) {
-        continue;
-      }
-      const file = await open(resolved, "r");
-      try {
-        const available = Math.min(
-          UNTRACKED_FILE_MAX_BYTES,
-          UNTRACKED_TOTAL_MAX_BYTES - total
-        );
-        if (available <= 0) {
-          break;
-        }
-        const buffer = Buffer.alloc(available + 1);
-        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
-        const text = redactAndCapText(
-          buffer.subarray(0, bytesRead).toString("utf8"),
-          available,
-          redact
-        );
-        const bytes = Buffer.byteLength(text, "utf8");
-        attachments.push({ bytes, path: normalizedName, text });
-        total += bytes;
-      } finally {
-        await file.close();
+      const attachment = await readAttachment(
+        root,
+        normalizedName,
+        redact,
+        available
+      );
+      if (attachment) {
+        attachments.push(attachment);
+        total += attachment.bytes;
       }
     } catch {
       /* refuse unreadable or non-git paths */
@@ -119,3 +189,21 @@ export const readUntrackedFiles = async (
   }
   return attachments;
 };
+
+/** Reads exact tracked working-tree files only when explicitly enabled. */
+export const readTrackedFiles = (
+  cwd: string,
+  requested: string[],
+  enabled: boolean,
+  redact: boolean,
+  totalLimit = ADVISOR_FILES_TOTAL_MAX_BYTES
+) => readFiles(cwd, requested, enabled, redact, "tracked", totalLimit);
+
+/** Returns exact, permitted untracked regular-file bodies. Refusals are silent. */
+export const readUntrackedFiles = (
+  cwd: string,
+  requested: string[],
+  enabled: boolean,
+  redact: boolean,
+  totalLimit = ADVISOR_FILES_TOTAL_MAX_BYTES
+) => readFiles(cwd, requested, enabled, redact, "untracked", totalLimit);