pi-advisor-flow 0.2.4 → 0.2.7

package/src/ui.ts

@@ -195,9 +195,12 @@ export interface AdvisorSettings {
   effort?: string;
   failureGate: boolean;
   failureMode?: "block-session" | "block-tool" | "warn-and-continue";
+  gitContext?: "off" | "summary" | "full";
+  gitContextMaxChars?: number;
   herdrIntegration?: boolean;
   loopThreshold?: number;
   maxCallsPerSession?: number;
+  outcomeLogging?: boolean;
   planGate: boolean;
   redactSecrets?: boolean;
   sessionSummary?: boolean;
@@ -205,6 +208,7 @@ export interface AdvisorSettings {
   toolPolicies?: Record<string, "full" | "summary" | "exclude">;
   toolResultMaxBytes?: number;
   toolResultMaxLines?: number;
+  untrackedContent?: boolean;
 }
 
 type AdvisorSettingsRow =
@@ -227,7 +231,11 @@ type AdvisorSettingsRow =
   | "toolResultMaxLines"
   | "toolResultMaxBytes"
   | "redactSecrets"
+  | "gitContext"
+  | "gitContextMaxChars"
   | "toolPolicies"
+  | "outcomeLogging"
+  | "untrackedContent"
   | "save";
 
 const ADVANCED_ROWS: AdvisorSettingsRow[] = [
@@ -248,7 +256,11 @@ const ADVANCED_ROWS: AdvisorSettingsRow[] = [
   "toolResultMaxLines",
   "toolResultMaxBytes",
   "redactSecrets",
+  "gitContext",
+  "gitContextMaxChars",
   "toolPolicies",
+  "untrackedContent",
+  "outcomeLogging",
 ];
 
 const SIMPLE_MODE_GRADIENT_INTERVAL_MS = 100;
@@ -361,7 +373,13 @@ export class AdvisorSettingsSelector implements Component, Focusable {
   private visibleRows(): AdvisorSettingsRow[] {
     return this.settings.simpleMode
       ? ["context", "simpleMode", "alwaysOn", "save"]
-      : ["simpleMode", "alwaysOn", ...ADVANCED_ROWS, "save"];
+      : [
+          "context",
+          "simpleMode",
+          "alwaysOn",
+          ...ADVANCED_ROWS.slice(1),
+          "save",
+        ];
   }
 
   private selectedRowId(): AdvisorSettingsRow {
@@ -465,10 +483,58 @@ export class AdvisorSettingsSelector implements Component, Focusable {
     this.options.onCancel();
   }
 
+  /** Disclosure and output-limit rows, split out to keep each builder simple. */
+  private disclosureRows(): string[] {
+    const onOff = (value: boolean) => (value ? "On" : "Off");
+    return [
+      this.row(
+        "Tool result lines",
+        String(this.settings.toolResultMaxLines ?? 2000),
+        "toolResultMaxLines"
+      ),
+      this.row(
+        "Tool result bytes",
+        String(this.settings.toolResultMaxBytes ?? 50 * 1024),
+        "toolResultMaxBytes"
+      ),
+      this.row(
+        "Redact common secrets",
+        onOff(this.settings.redactSecrets ?? false),
+        "redactSecrets"
+      ),
+      this.row(
+        "Repository context",
+        this.settings.gitContext ?? "summary",
+        "gitContext"
+      ),
+      this.row(
+        "Repository context chars",
+        String(this.settings.gitContextMaxChars ?? 20_000),
+        "gitContextMaxChars"
+      ),
+      this.row(
+        "Tool disclosure policies",
+        Object.keys(this.settings.toolPolicies ?? {}).length
+          ? "Exact names configured"
+          : "All tools: full",
+        "toolPolicies"
+      ),
+      this.row(
+        "Untracked file content",
+        onOff(this.settings.untrackedContent ?? false),
+        "untrackedContent"
+      ),
+      this.row(
+        "Outcome logging (global)",
+        onOff(this.settings.outcomeLogging ?? false),
+        "outcomeLogging"
+      ),
+    ];
+  }
+
   private advancedRows(width: number): string[] {
     const onOff = (value: boolean) => (value ? "On" : "Off");
     const rows = [
-      this.row("Context window", this.currentContext().label, "context"),
       this.row("Advisor reasoning", this.currentEffort(), "effort"),
       this.row("Plan gate", onOff(this.settings.planGate), "planGate"),
       this.row("Failure gate", onOff(this.settings.failureGate), "failureGate"),
@@ -524,28 +590,7 @@ export class AdvisorSettingsSelector implements Component, Focusable {
         onOff(this.settings.herdrIntegration ?? true),
         "herdrIntegration"
       ),
-      this.row(
-        "Tool result lines",
-        String(this.settings.toolResultMaxLines ?? 2000),
-        "toolResultMaxLines"
-      ),
-      this.row(
-        "Tool result bytes",
-        String(this.settings.toolResultMaxBytes ?? 50 * 1024),
-        "toolResultMaxBytes"
-      ),
-      this.row(
-        "Redact common secrets",
-        onOff(this.settings.redactSecrets ?? false),
-        "redactSecrets"
-      ),
-      this.row(
-        "Tool disclosure policies",
-        Object.keys(this.settings.toolPolicies ?? {}).length
-          ? "Exact names configured"
-          : "All tools: full",
-        "toolPolicies"
-      ),
+      ...this.disclosureRows(),
     ];
     if (this.editingCustom) {
       rows.push(
@@ -630,6 +675,9 @@ export class AdvisorSettingsSelector implements Component, Focusable {
       }
     }
     const heading = `Recent history${" ".repeat(Math.max(1, trackWidth - "Recent history".length - "Full branch".length))}Full branch`;
+    lines.push(
+      `  ${this.row("Context window", this.currentContext().label, "context")}`
+    );
     lines.push(`  ${theme.fg("muted", heading)}`);
     lines.push(`  ${theme.fg("muted", track.join(""))}`);
     lines.push(`  ${theme.fg("text", labels.join(""))}`);
@@ -794,6 +842,38 @@ export class AdvisorSettingsSelector implements Component, Focusable {
       case "redactSecrets":
         this.settings.redactSecrets = !(this.settings.redactSecrets ?? false);
         break;
+      case "untrackedContent":
+        this.settings.untrackedContent = !(
+          this.settings.untrackedContent ?? false
+        );
+        break;
+      case "outcomeLogging":
+        this.settings.outcomeLogging = !(this.settings.outcomeLogging ?? false);
+        break;
+      case "gitContext": {
+        const levels: AdvisorSettings["gitContext"][] = [
+          "off",
+          "summary",
+          "full",
+        ];
+        const index = Math.max(
+          0,
+          levels.indexOf(this.settings.gitContext ?? "summary")
+        );
+        this.settings.gitContext =
+          levels[Math.max(0, Math.min(levels.length - 1, index + direction))];
+        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 =
+          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(

package/src/untracked.ts

@@ -0,0 +1,121 @@
+import { execFileSync } from "node:child_process";
+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 interface UntrackedAttachment {
+  bytes: number;
+  path: string;
+  text: string;
+}
+
+const PATH_SEGMENTS = /[\\/]/;
+
+const within = (root: string, candidate: string) => {
+  const path = relative(root, candidate);
+  return path !== "" && !path.startsWith("..") && !path.includes("../");
+};
+const normalizeRelativePath = (root: string, path: string) =>
+  relative(root, resolve(root, path));
+
+const normalizeRequestedPath = (root: string, value: unknown) => {
+  if (
+    typeof value !== "string" ||
+    !value ||
+    isAbsolute(value) ||
+    value.split(PATH_SEGMENTS).includes("..")
+  ) {
+    return;
+  }
+  return normalizeRelativePath(root, value);
+};
+
+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 expected = normalizeRelativePath(cwd, path);
+  return output
+    .split("\0")
+    .filter(Boolean)
+    .some((entry) => normalizeRelativePath(cwd, entry) === expected);
+};
+
+/** Returns only exact, permitted untracked regular-file bodies. Refusals are silent. */
+export const readUntrackedFiles = async (
+  cwd: string,
+  requested: string[],
+  enabled: boolean,
+  redact: boolean
+): Promise<UntrackedAttachment[]> => {
+  if (!(enabled && Array.isArray(requested))) {
+    return [];
+  }
+  const root = await realpath(cwd).catch(() => undefined);
+  if (!root) {
+    return [];
+  }
+  const unique = new Set<string>();
+  const attachments: UntrackedAttachment[] = [];
+  let total = 0;
+  for (const name of requested) {
+    const normalizedName = normalizeRequestedPath(root, name);
+    if (!normalizedName || unique.has(normalizedName)) {
+      continue;
+    }
+    unique.add(normalizedName);
+    try {
+      const absolute = resolve(root, normalizedName);
+      if (!(within(root, absolute) && untracked(root, normalizedName))) {
+        continue;
+      }
+      // 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();
+      }
+    } catch {
+      /* refuse unreadable or non-git paths */
+    }
+  }
+  return attachments;
+};