pi-advisor-flow 0.2.0 → 0.2.2

package/src/config.ts

@@ -120,6 +120,29 @@ export const setAdvisorToolResultMaxBytesRef = (value: number) => {
   advisorToolResultMaxBytesRef = value;
 };
 
+/**
+ * Returns the current live settings state. Use this at UI boundaries instead of
+ * imported mutable bindings, which can be snapshotted by extension loaders.
+ */
+export const getAdvisorSettings = () => ({
+  autoLoopGate: advisorAutoLoopGateRef,
+  blockOnBlocked: advisorBlockOnBlockedRef,
+  collapseResponses: advisorCollapseResponsesRef,
+  completionGate: advisorCompletionGateRef,
+  contextMaxChars: contextMaxCharsRef,
+  customRule: advisorCustomInvocationRef,
+  effort: advisorEffortRef,
+  failureGate: advisorFailureGateRef,
+  failureMode: advisorFailureModeRef,
+  herdrIntegration: advisorHerdrIntegrationRef,
+  loopThreshold: advisorLoopThresholdRef,
+  maxCallsPerSession: advisorMaxCallsPerSessionRef,
+  planGate: advisorPlanGateRef,
+  sessionSummary: advisorSessionSummaryRef,
+  toolResultMaxBytes: advisorToolResultMaxBytesRef,
+  toolResultMaxLines: advisorToolResultMaxLinesRef,
+});
+
 export const splitRef = (ref: string): [string, string] => {
   const i = ref.indexOf("/");
   return i === -1 ? ["aikeys", ref] : [ref.slice(0, i), ref.slice(i + 1)];
@@ -154,127 +177,149 @@ export interface AdvisorConfig {
   gateFailureMode?: GateFailureMode;
 }
 
-const CONFIG_KEYS = new Set(
-  Object.keys({
-    advisor: true,
-    advisorAutoLoopGate: true,
-    advisorBlockOnBlocked: true,
-    advisorCollapseResponses: true,
-    advisorCompletionGate: true,
-    advisorCustomInvocation: true,
-    advisorEffort: true,
-    advisorFailureGate: true,
-    advisorHerdrIntegration: true,
-    advisorLoopThreshold: true,
-    advisorMaxCallsPerSession: true,
-    advisorPlanGate: true,
-    advisorSessionSummary: true,
-    advisorToolResultMaxBytes: true,
-    advisorToolResultMaxLines: true,
-    contextMaxChars: true,
-    executor: true,
-    executorEffort: true,
-    gateFailureMode: true,
-  })
-);
+const CONFIG_KEYS = new Set<keyof AdvisorConfig>([
+  "advisor",
+  "advisorAutoLoopGate",
+  "advisorBlockOnBlocked",
+  "advisorCollapseResponses",
+  "advisorCompletionGate",
+  "advisorCustomInvocation",
+  "advisorEffort",
+  "advisorFailureGate",
+  "advisorHerdrIntegration",
+  "advisorLoopThreshold",
+  "advisorMaxCallsPerSession",
+  "advisorPlanGate",
+  "advisorSessionSummary",
+  "advisorToolResultMaxBytes",
+  "advisorToolResultMaxLines",
+  "contextMaxChars",
+  "executor",
+  "executorEffort",
+  "gateFailureMode",
+]);
+const BOOLEAN_CONFIG_KEYS = [
+  "advisorPlanGate",
+  "advisorFailureGate",
+  "advisorCompletionGate",
+  "advisorCollapseResponses",
+  "advisorBlockOnBlocked",
+  "advisorAutoLoopGate",
+  "advisorSessionSummary",
+  "advisorHerdrIntegration",
+] as const;
+const STRING_CONFIG_KEYS = [
+  "executor",
+  "advisor",
+  "executorEffort",
+  "advisorEffort",
+  "advisorCustomInvocation",
+] as const;
+const ARGUMENT_WHITESPACE = /\s+/;
 
-export const validateConfig = (
-  value: unknown,
-  path = "advisor.json"
-): value is AdvisorConfig => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new TypeError(
-      `Invalid advisor configuration at ${path}: expected a JSON object.`
-    );
-  }
-  const config = value as Record<string, unknown>;
-  const unknown = Object.keys(config).filter((key) => !CONFIG_KEYS.has(key));
-  if (unknown.length) {
-    throw new TypeError(
-      `Invalid advisor configuration at ${path}: unknown key(s) ${unknown.map((key) => JSON.stringify(key)).join(", ")}. Remove them or upgrade pi-advisor.`
-    );
-  }
-  const invalid = (key: string, accepted: string) => {
+type ConfigRecord = Record<string, unknown>;
+
+const invalidConfigValue = (
+  path: string,
+  key: string,
+  accepted: string
+): never => {
+  throw new TypeError(
+    `Invalid advisor configuration at ${path}, key ${JSON.stringify(key)}: expected ${accepted}.`
+  );
+};
+
+const validateKnownKeys = (config: ConfigRecord, path: string) => {
+  const unknownKeys = Object.keys(config).filter(
+    (key) => !CONFIG_KEYS.has(key as keyof AdvisorConfig)
+  );
+  if (unknownKeys.length > 0) {
     throw new TypeError(
-      `Invalid advisor configuration at ${path}, key ${JSON.stringify(key)}: expected ${accepted}.`
+      `Invalid advisor configuration at ${path}: unknown key(s) ${unknownKeys.map((key) => JSON.stringify(key)).join(", ")}. Remove them or upgrade pi-advisor.`
     );
-  };
-  if (config.executor !== undefined && typeof config.executor !== "string") {
-    invalid("executor", "a provider/model string");
-  }
-  if (config.advisor !== undefined && typeof config.advisor !== "string") {
-    invalid("advisor", "a provider/model string");
-  }
-  if (
-    config.executorEffort !== undefined &&
-    typeof config.executorEffort !== "string"
-  ) {
-    invalid("executorEffort", "a string");
   }
-  if (
-    config.advisorEffort !== undefined &&
-    typeof config.advisorEffort !== "string"
-  ) {
-    invalid("advisorEffort", "a string");
-  }
-  if (
-    config.contextMaxChars !== undefined &&
-    !isValidContextMaxChars(config.contextMaxChars)
-  ) {
-    invalid(
-      "contextMaxChars",
-      `a safe integer from 0 through ${MAX_CONTEXT_MAX_CHARS}`
-    );
+};
+
+const validateStringValues = (config: ConfigRecord, path: string) => {
+  for (const key of STRING_CONFIG_KEYS) {
+    if (config[key] !== undefined && typeof config[key] !== "string") {
+      invalidConfigValue(
+        path,
+        key,
+        key === "executor" || key === "advisor"
+          ? "a provider/model string"
+          : "a string"
+      );
+    }
   }
-  for (const key of [
-    "advisorPlanGate",
-    "advisorFailureGate",
-    "advisorCompletionGate",
-    "advisorCollapseResponses",
-    "advisorBlockOnBlocked",
-    "advisorAutoLoopGate",
-    "advisorSessionSummary",
-    "advisorHerdrIntegration",
-  ]) {
+};
+
+const validateBooleanValues = (config: ConfigRecord, path: string) => {
+  for (const key of BOOLEAN_CONFIG_KEYS) {
     if (config[key] !== undefined && typeof config[key] !== "boolean") {
-      invalid(key, "true or false");
+      invalidConfigValue(path, key, "true or false");
     }
   }
-  if (
-    config.advisorCustomInvocation !== undefined &&
-    typeof config.advisorCustomInvocation !== "string"
-  ) {
-    invalid("advisorCustomInvocation", "a string");
-  }
-  if (
-    config.advisorLoopThreshold !== undefined &&
-    !isValidLoopThreshold(config.advisorLoopThreshold)
-  ) {
-    invalid("advisorLoopThreshold", "a safe integer of at least 2");
+};
+
+const validateNumericValues = (config: ConfigRecord, path: string) => {
+  const numericRules: [
+    keyof AdvisorConfig,
+    (value: unknown) => boolean,
+    string,
+  ][] = [
+    [
+      "contextMaxChars",
+      isValidContextMaxChars,
+      `a safe integer from 0 through ${MAX_CONTEXT_MAX_CHARS}`,
+    ],
+    [
+      "advisorLoopThreshold",
+      isValidLoopThreshold,
+      "a safe integer of at least 2",
+    ],
+    [
+      "advisorMaxCallsPerSession",
+      isValidMaxCallsPerSession,
+      "a non-negative safe integer",
+    ],
+    [
+      "advisorToolResultMaxLines",
+      isValidToolResultMaxLines,
+      "a non-negative safe integer",
+    ],
+    [
+      "advisorToolResultMaxBytes",
+      isValidToolResultMaxBytes,
+      "a non-negative safe integer",
+    ],
+  ];
+  for (const [key, isValid, description] of numericRules) {
+    if (config[key] !== undefined && !isValid(config[key])) {
+      invalidConfigValue(path, key, description);
+    }
   }
-  if (
-    config.advisorMaxCallsPerSession !== undefined &&
-    !isValidMaxCallsPerSession(config.advisorMaxCallsPerSession)
-  ) {
-    invalid("advisorMaxCallsPerSession", "a non-negative safe integer");
+};
+
+export const validateConfig = (
+  value: unknown,
+  path = "advisor.json"
+): value is AdvisorConfig => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(
+      `Invalid advisor configuration at ${path}: expected a JSON object.`
+    );
   }
+  const config = value as ConfigRecord;
+  validateKnownKeys(config, path);
+  validateStringValues(config, path);
+  validateBooleanValues(config, path);
+  validateNumericValues(config, path);
   if (
     config.gateFailureMode !== undefined &&
     !isValidGateFailureMode(config.gateFailureMode)
   ) {
-    invalid("gateFailureMode", GATE_FAILURE_MODES.join(", "));
-  }
-  if (
-    config.advisorToolResultMaxLines !== undefined &&
-    !isValidToolResultMaxLines(config.advisorToolResultMaxLines)
-  ) {
-    invalid("advisorToolResultMaxLines", "a non-negative safe integer");
-  }
-  if (
-    config.advisorToolResultMaxBytes !== undefined &&
-    !isValidToolResultMaxBytes(config.advisorToolResultMaxBytes)
-  ) {
-    invalid("advisorToolResultMaxBytes", "a non-negative safe integer");
+    invalidConfigValue(path, "gateFailureMode", GATE_FAILURE_MODES.join(", "));
   }
   return true;
 };
@@ -301,79 +346,109 @@ const resetDefaults = () => {
   advisorToolResultMaxBytesRef = DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES;
 };
 
+const applyOptionalConfig = <Key extends keyof AdvisorConfig>(
+  config: AdvisorConfig,
+  key: Key,
+  apply: (value: NonNullable<AdvisorConfig[Key]>) => void
+) => {
+  const value = config[key];
+  if (value !== undefined) {
+    apply(value as NonNullable<AdvisorConfig[Key]>);
+  }
+};
+
+const applyNonEmptyStringConfig = (
+  value: string | undefined,
+  apply: (value: string) => void
+) => {
+  if (value) {
+    apply(value);
+  }
+};
+
+const applyConfig = (config: AdvisorConfig) => {
+  applyNonEmptyStringConfig(config.executor, setExecutorRef);
+  applyNonEmptyStringConfig(config.advisor, setAdvisorRef);
+  applyNonEmptyStringConfig(config.executorEffort, setExecutorEffortRef);
+  applyNonEmptyStringConfig(config.advisorEffort, setAdvisorEffortRef);
+  applyOptionalConfig(config, "contextMaxChars", setContextMaxCharsRef);
+  applyOptionalConfig(config, "advisorPlanGate", setAdvisorPlanGateRef);
+  applyOptionalConfig(config, "advisorFailureGate", setAdvisorFailureGateRef);
+  applyOptionalConfig(
+    config,
+    "advisorCompletionGate",
+    setAdvisorCompletionGateRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorCustomInvocation",
+    setAdvisorCustomInvocationRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorCollapseResponses",
+    setAdvisorCollapseResponsesRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorBlockOnBlocked",
+    setAdvisorBlockOnBlockedRef
+  );
+  applyOptionalConfig(config, "advisorAutoLoopGate", setAdvisorAutoLoopGateRef);
+  applyOptionalConfig(
+    config,
+    "advisorLoopThreshold",
+    setAdvisorLoopThresholdRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorMaxCallsPerSession",
+    setAdvisorMaxCallsPerSessionRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorSessionSummary",
+    setAdvisorSessionSummaryRef
+  );
+  applyOptionalConfig(config, "gateFailureMode", setAdvisorFailureModeRef);
+  applyOptionalConfig(
+    config,
+    "advisorHerdrIntegration",
+    setAdvisorHerdrIntegrationRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorToolResultMaxLines",
+    setAdvisorToolResultMaxLinesRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorToolResultMaxBytes",
+    setAdvisorToolResultMaxBytesRef
+  );
+};
+
+const readConfig = (path: string): AdvisorConfig => {
+  try {
+    const config = JSON.parse(readFileSync(path, "utf8"));
+    validateConfig(config, path);
+    return config;
+  } catch (error) {
+    throw error instanceof Error ? error : new Error(String(error));
+  }
+};
+
 export const loadConfig = (ctx: ExtensionContext) => {
   resetDefaults();
-  for (const path of configPaths(ctx)) {
-    if (!(path && existsSync(path))) {
-      continue;
-    }
-    let config: AdvisorConfig;
-    try {
-      config = JSON.parse(readFileSync(path, "utf8")) as AdvisorConfig;
-      validateConfig(config, path);
-    } catch (error) {
-      throw error instanceof Error ? error : new Error(String(error));
-    }
-    if (config.executor) {
-      executorRef = config.executor;
-    }
-    if (config.advisor) {
-      advisorRef = config.advisor;
-    }
-    if (config.executorEffort) {
-      executorEffortRef = config.executorEffort;
-    }
-    if (config.advisorEffort) {
-      advisorEffortRef = config.advisorEffort;
-    }
-    if (config.contextMaxChars !== undefined) {
-      contextMaxCharsRef = config.contextMaxChars;
-    }
-    if (config.advisorPlanGate !== undefined) {
-      advisorPlanGateRef = config.advisorPlanGate;
-    }
-    if (config.advisorFailureGate !== undefined) {
-      advisorFailureGateRef = config.advisorFailureGate;
-    }
-    if (config.advisorCompletionGate !== undefined) {
-      advisorCompletionGateRef = config.advisorCompletionGate;
-    }
-    if (config.advisorCustomInvocation !== undefined) {
-      advisorCustomInvocationRef = config.advisorCustomInvocation || undefined;
-    }
-    if (config.advisorCollapseResponses !== undefined) {
-      advisorCollapseResponsesRef = config.advisorCollapseResponses;
-    }
-    if (config.advisorBlockOnBlocked !== undefined) {
-      advisorBlockOnBlockedRef = config.advisorBlockOnBlocked;
-    }
-    if (config.advisorAutoLoopGate !== undefined) {
-      advisorAutoLoopGateRef = config.advisorAutoLoopGate;
-    }
-    if (config.advisorLoopThreshold !== undefined) {
-      advisorLoopThresholdRef = config.advisorLoopThreshold;
-    }
-    if (config.advisorMaxCallsPerSession !== undefined) {
-      advisorMaxCallsPerSessionRef = config.advisorMaxCallsPerSession;
-    }
-    if (config.advisorSessionSummary !== undefined) {
-      advisorSessionSummaryRef = config.advisorSessionSummary;
-    }
-    if (config.gateFailureMode !== undefined) {
-      advisorFailureModeRef = config.gateFailureMode;
-    }
-    if (config.advisorHerdrIntegration !== undefined) {
-      advisorHerdrIntegrationRef = config.advisorHerdrIntegration;
-    }
-    if (config.advisorToolResultMaxLines !== undefined) {
-      advisorToolResultMaxLinesRef = config.advisorToolResultMaxLines;
-    }
-    if (config.advisorToolResultMaxBytes !== undefined) {
-      advisorToolResultMaxBytesRef = config.advisorToolResultMaxBytes;
-    }
-    return path;
+  const path = configPaths(ctx).find(
+    (candidate): candidate is string =>
+      candidate !== null && existsSync(candidate)
+  );
+  if (!path) {
+    return null;
   }
-  return null;
+  applyConfig(readConfig(path));
+  return path;
 };
 
 export const saveConfig = (ctx: ExtensionContext) => {
@@ -391,6 +466,9 @@ export const saveConfig = (ctx: ExtensionContext) => {
   } catch {
     /* replace a missing or malformed file */
   }
+  if (advisorMaxCallsPerSessionRef === undefined) {
+    existing.advisorMaxCallsPerSession = undefined;
+  }
   const data = {
     ...existing,
     advisor: advisorRef,
@@ -423,7 +501,7 @@ export const parseArgs = (args: string): string | undefined => {
   let nextExecutor = executorRef;
   let nextAdvisor = advisorRef;
   let nextContextMaxChars = contextMaxCharsRef;
-  for (const token of args.trim().split(/\s+/).filter(Boolean)) {
+  for (const token of args.trim().split(ARGUMENT_WHITESPACE).filter(Boolean)) {
     const [key, value] = token.split("=");
     if (key === "executor" && value) {
       nextExecutor = value;

package/src/conversation.ts

@@ -69,30 +69,49 @@ export const capToolResult = (
   }
 
   const marker = "[... omitted tool-result section ...]";
-  const availableBytes = Math.max(0, maxBytes - byteLength(marker) - 2);
-  const headCount = Math.max(1, Math.floor(Math.max(1, maxLines - 1) / 2));
-  const tailCount = Math.max(1, Math.max(1, maxLines - 1) - headCount);
-  const head: string[] = [];
-  let headBytes = 0;
-  for (const line of lines.slice(0, headCount)) {
-    const next = headBytes + byteLength(line) + (head.length ? 1 : 0);
-    if (head.length && next > Math.ceil(availableBytes / 2)) {
-      break;
-    }
-    head.push(line);
-    headBytes = next;
-  }
-  const tail: string[] = [];
-  let tailBytes = 0;
-  const tailStart = Math.max(head.length, lines.length - tailCount);
-  for (const line of lines.slice(tailStart)) {
-    const next = tailBytes + byteLength(line) + (tail.length ? 1 : 0);
-    if (tail.length && next > Math.floor(availableBytes / 2)) {
-      break;
-    }
-    tail.push(line);
-    tailBytes = next;
+  const markerBytes = byteLength(marker);
+  if (maxBytes < markerBytes || maxLines === 1) {
+    const content = [...marker].reduce(
+      (result, character) =>
+        byteLength(result + character) <= maxBytes
+          ? result + character
+          : result,
+      ""
+    );
+    return {
+      content,
+      omittedLines: totalLines,
+      totalBytes,
+      totalLines,
+      truncated: true,
+    };
   }
+  const headCount = Math.floor((maxLines - 1) / 2);
+  const tailCount = maxLines - 1 - headCount;
+  const collect = (
+    candidates: string[],
+    maxEntries: number,
+    maxContentBytes: number
+  ) => {
+    const selected: string[] = [];
+    let used = 0;
+    for (const line of candidates.slice(0, maxEntries)) {
+      const next = used + byteLength(line) + (selected.length ? 1 : 0);
+      if (next > maxContentBytes) {
+        break;
+      }
+      selected.push(line);
+      used = next;
+    }
+    return selected;
+  };
+  const availableBytes = maxBytes - markerBytes - 2;
+  const head = collect(lines, headCount, Math.floor(availableBytes / 2));
+  const tail = collect(
+    lines.slice(Math.max(head.length, lines.length - tailCount)),
+    tailCount,
+    availableBytes - byteLength(head.join("\n"))
+  );
   const content = [...head, marker, ...tail].join("\n");
   return {
     content,
@@ -150,7 +169,7 @@ const conversationEntry = (
   if (entry.type !== "message" || !isRecord(entry.message)) {
     return;
   }
-  const message = entry.message;
+  const { message } = entry;
   if (message.role === "user") {
     const text = textFrom(message.content);
     return text ? `User: ${text}` : undefined;

package/src/herdr.ts

@@ -171,10 +171,11 @@ export class HerdrAdvisorBlock {
   }
 
   clear() {
-    if (!this.isBlocked()) {
+    const wasBlocked: boolean = this.#blocked;
+    this.#blocked = false;
+    if (!wasBlocked) {
       return;
     }
-    this.#blocked = false;
     if (!this.enabled()) {
       return;
     }
@@ -196,10 +197,6 @@ export class HerdrAdvisorBlock {
     }
   }
 
-  private isBlocked() {
-    return this.#blocked;
-  }
-
   private safeReport(labels: { blocked: string }) {
     try {
       this.report({

package/src/session-state.ts

@@ -19,10 +19,18 @@ export interface AdvisorInvocationRecord {
 }
 
 const WHITESPACE = /\s/;
-const TIMESTAMP_KEY = /timestamp|time|date/;
-const REQUEST_ID_KEY = /requestid|correlationid|traceid/;
-const isVolatileKey = (key: string, pattern: RegExp) =>
-  pattern.test(key.replace(/[-_]/g, "").toLowerCase());
+const TIMESTAMP_KEYS = new Set([
+  "createdat",
+  "date",
+  "datetime",
+  "time",
+  "timestamp",
+  "updatedat",
+]);
+const REQUEST_ID_KEYS = new Set(["correlationid", "requestid", "traceid"]);
+const normalizedKey = (key: string) => key.replace(/[-_]/g, "").toLowerCase();
+const isVolatileKey = (key: string, keys: Set<string>) =>
+  keys.has(normalizedKey(key));
 
 const normalizeShellWhitespace = (command: string) => {
   let result = "";
@@ -67,10 +75,10 @@ export const normalizeToolInput = (
 ): unknown => {
   const visit = (value: unknown, key?: string): unknown => {
     if (typeof value === "string") {
-      if (key && isVolatileKey(key, TIMESTAMP_KEY)) {
+      if (key && isVolatileKey(key, TIMESTAMP_KEYS)) {
         return "<timestamp>";
       }
-      if (key && isVolatileKey(key, REQUEST_ID_KEY)) {
+      if (key && isVolatileKey(key, REQUEST_ID_KEYS)) {
         return "<request-id>";
       }
       const normalized = normalizeString(value);