@hassangameryt/freeflow 0.2.0 → 0.4.0

package/pi-extension/tests/settings/settings-tui.test.js

@@ -0,0 +1,243 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { CURSOR_MARKER, visibleWidth } from "@earendil-works/pi-tui";
+
+import { PiSettingsComponent } from "../../dist/settings/settings-tui.js";
+
+const theme = {
+  fg(_color, text) {
+    return text;
+  },
+  bold(text) {
+    return text;
+  },
+};
+
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
+function createComponent(entries, options = {}) {
+  const notifications = [];
+  let closed = false;
+  const component = new PiSettingsComponent({
+    title: options.title ?? "Test Settings",
+    entries,
+    theme: options.theme ?? theme,
+    requestRender() {},
+    notify(message, level) {
+      notifications.push({ message, level });
+    },
+    done() {
+      closed = true;
+    },
+  });
+  return { component, notifications, isClosed: () => closed };
+}
+
+test("Pi settings publish values only after persistence and block concurrent edits", async () => {
+  let current = "disabled";
+  let commits = 0;
+  const write = deferred();
+  const entry = {
+    id: "feature.enabled",
+    label: "Feature",
+    description: "Enable the feature.",
+    currentValue: () => current,
+    inactive: () => false,
+    currentChoiceKey: () => (current === "enabled" ? "true" : "false"),
+    choices: [
+      { key: "true", value: true, label: "enabled" },
+      { key: "false", value: false, label: "disabled" },
+    ],
+    async commit() {
+      commits += 1;
+      await write.promise;
+      current = "enabled";
+      return { changed: true, reloadRequired: true };
+    },
+  };
+  const { component } = createComponent([entry]);
+
+  component.handleInput("\r");
+  component.handleInput("\u001b[A");
+  component.handleInput("\r");
+  component.handleInput("\r");
+
+  assert.equal(commits, 1);
+  assert.equal(current, "disabled");
+  write.resolve();
+  await component.waitForWrites();
+  assert.equal(current, "enabled");
+  assert.match(component.render(80).join("\n"), /Feature\s+enabled/);
+  assert.deepEqual(component.sessionResult(), { changed: true, configChanged: true, failed: false });
+});
+
+test("Pi settings retain the persisted value when a write fails", async () => {
+  const current = "disabled";
+  const entry = {
+    id: "feature.enabled",
+    label: "Feature",
+    description: "Enable the feature.",
+    currentValue: () => current,
+    inactive: () => false,
+    currentChoiceKey: () => "false",
+    choices: [
+      { key: "true", value: true, label: "enabled" },
+      { key: "false", value: false, label: "disabled" },
+    ],
+    async commit() {
+      throw new Error("disk unavailable");
+    },
+  };
+  const { component, notifications } = createComponent([entry]);
+
+  component.handleInput("\r");
+  component.handleInput("\u001b[A");
+  component.handleInput("\r");
+  await component.waitForWrites();
+  component.handleInput("\u001b");
+
+  assert.equal(current, "disabled");
+  assert.match(component.render(80).join("\n"), /Feature\s+disabled/);
+  assert.deepEqual(component.sessionResult(), { changed: false, configChanged: false, failed: true });
+  assert.deepEqual(notifications, [{ message: "Write failed: disk unavailable", level: "error" }]);
+});
+
+test("Pi settings delegate paste, cursor, grapheme, and IME behavior to Input", async () => {
+  let current = "";
+  const entry = {
+    id: "feature.label",
+    label: "Label",
+    description: "Unicode label.",
+    currentValue: () => current,
+    inactive: () => false,
+    edit: {
+      initialValue: () => current,
+      parse: (text) => text,
+    },
+    async commit(value) {
+      current = value;
+      return { changed: true, reloadRequired: true };
+    },
+  };
+  const { component } = createComponent([entry]);
+  component.focused = true;
+
+  component.handleInput("\r");
+  assert.ok(component.render(40).join("\n").includes(CURSOR_MARKER));
+  component.handleInput("\u001b[200~ab🙂\u001b[201~");
+  component.handleInput("\u001b[D");
+  component.handleInput("\u007f");
+  component.handleInput("界");
+  component.handleInput("\r");
+  await component.waitForWrites();
+
+  assert.equal(current, "a界🙂");
+});
+
+test("Pi settings start value editing at the end of the existing value", async () => {
+  let current = "abc";
+  const entry = {
+    id: "feature.label",
+    label: "Label",
+    description: "Editable label.",
+    currentValue: () => current,
+    inactive: () => false,
+    edit: {
+      initialValue: () => current,
+      parse: (text) => text,
+    },
+    async commit(value) {
+      current = value;
+      return { changed: true, reloadRequired: true };
+    },
+  };
+  const { component } = createComponent([entry]);
+
+  component.handleInput("\r");
+  component.handleInput("X");
+  component.handleInput("\r");
+  await component.waitForWrites();
+
+  assert.equal(current, "abcX");
+});
+
+test("Pi settings keep typed input open when parsing fails", () => {
+  let commits = 0;
+  const entry = {
+    id: "feature.limit",
+    label: "Limit",
+    description: "Positive integer.",
+    currentValue: () => "1",
+    inactive: () => false,
+    edit: {
+      initialValue: () => "",
+      parse(text) {
+        const value = Number(text);
+        if (!Number.isInteger(value) || value <= 0) throw new Error("expected a positive integer");
+        return value;
+      },
+    },
+    async commit() {
+      commits += 1;
+      return { changed: true, reloadRequired: true };
+    },
+  };
+  const { component } = createComponent([entry]);
+
+  component.handleInput("\r");
+  component.handleInput("invalid");
+  component.handleInput("\r");
+
+  assert.equal(commits, 0);
+  assert.match(component.render(60).join("\n"), /Invalid value: expected a positive integer/);
+});
+
+test("Pi settings search accepts bracketed paste", () => {
+  const entries = ["Alpha", "Beta"].map((label) => ({
+    id: label.toLowerCase(),
+    label,
+    description: `${label} setting`,
+    currentValue: () => "off",
+    inactive: () => true,
+  }));
+  const { component } = createComponent(entries);
+
+  component.handleInput("\u001b[200~Beta\u001b[201~");
+  const rendered = component.render(60).join("\n");
+  assert.match(rendered, /Beta/);
+  assert.doesNotMatch(rendered, /Alpha/);
+});
+
+test("Pi settings keep ANSI and Unicode rendering within terminal width", () => {
+  const ansiTheme = {
+    fg(_color, text) {
+      return `\u001b[36m${text}\u001b[0m`;
+    },
+    bold(text) {
+      return `\u001b[1m${text}\u001b[22m`;
+    },
+  };
+  const entry = {
+    id: "unicode",
+    label: "設定🙂",
+    description: "幅の広い Unicode description with several words.",
+    currentValue: () => "有効界",
+    inactive: () => true,
+  };
+  const { component } = createComponent([entry], { title: "設定パネル", theme: ansiTheme });
+
+  for (const width of [12, 20, 40]) {
+    for (const line of component.render(width)) {
+      assert.ok(visibleWidth(line) <= width, `line width ${visibleWidth(line)} exceeds ${width}: ${line}`);
+    }
+  }
+});

package/pi-extension/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": false,
+    "sourceMap": false,
+    "strict": false,
+    "noEmitOnError": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/{plugins/freeflow/router/dist → router/dist/benchmarks}/benchmark-harness.d.ts

@@ -1,14 +1,14 @@
 export interface LatencySummary {
-    p50: number;
-    p95: number;
+  p50: number;
+  p95: number;
 }
 export interface BenchmarkCliDefaults {
-    reportPath: string;
+  reportPath: string;
 }
 export interface ParsedBenchmarkCliArgs {
-    iterations?: number;
-    reportPath: string;
-    jsonReportPath?: string | false;
+  iterations?: number;
+  reportPath: string;
+  jsonReportPath?: string | false;
 }
 export declare function normalizeIterations(value: unknown, defaultIterations?: number): number;
 export declare function approximateTokens(bytes: number): number;
@@ -20,13 +20,16 @@ export declare function reductionPercent(raw: number, routed: number): number;
 export declare function formatPercent(value: number): string;
 export declare function escapeMarkdownTableCell(value: string): string;
 export declare function defaultJsonRunReportPath(markdownReportPath: string): string;
-export declare function parseBenchmarkCliArgs(argv: readonly string[], defaults: BenchmarkCliDefaults): ParsedBenchmarkCliArgs;
+export declare function parseBenchmarkCliArgs(
+  argv: readonly string[],
+  defaults: BenchmarkCliDefaults,
+): ParsedBenchmarkCliArgs;
 export declare function writeBenchmarkReportPair<TReport>(options: {
-    report: TReport;
-    markdownReportPath: string;
-    jsonReportPath?: string | false | undefined;
-    renderMarkdown(report: TReport): string;
+  report: TReport;
+  markdownReportPath: string;
+  jsonReportPath?: string | false | undefined;
+  renderMarkdown(report: TReport): string;
 }): Promise<{
-    markdown: string;
-    json?: string;
+  markdown: string;
+  json?: string;
 }>;

package/router/dist/benchmarks/benchmark-harness.js

@@ -0,0 +1,92 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
+export function normalizeIterations(value, defaultIterations = 3) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.max(1, Math.floor(value));
+  }
+  if (Number.isFinite(defaultIterations) && defaultIterations > 0) {
+    return Math.max(1, Math.floor(defaultIterations));
+  }
+  return 1;
+}
+export function approximateTokens(bytes) {
+  return Math.ceil(bytes / 4);
+}
+export function percentile(values, quantile) {
+  if (values.length === 0) {
+    return 0;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * quantile) - 1));
+  return sorted[index] ?? 0;
+}
+export function latencySummary(values) {
+  return {
+    p50: percentile(values, 0.5),
+    p95: percentile(values, 0.95),
+  };
+}
+export function averagePercent(values) {
+  if (values.length === 0) {
+    return 0;
+  }
+  return roundPercent(values.reduce((sum, value) => sum + value, 0) / values.length);
+}
+export function medianPercent(values) {
+  return roundPercent(percentile(values, 0.5));
+}
+export function reductionPercent(raw, routed) {
+  if (raw <= 0) {
+    return 0;
+  }
+  return roundPercent(((raw - routed) / raw) * 100);
+}
+export function formatPercent(value) {
+  return `${value.toFixed(2)}%`;
+}
+export function escapeMarkdownTableCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+export function defaultJsonRunReportPath(markdownReportPath) {
+  const markdownName = basename(markdownReportPath);
+  const jsonName = markdownName.endsWith(".md")
+    ? `${markdownName.slice(0, -".md".length)}.json`
+    : `${markdownName}.json`;
+  return resolve(process.cwd(), "router/evals/runs", jsonName);
+}
+export function parseBenchmarkCliArgs(argv, defaults) {
+  let iterations;
+  let reportPath = defaults.reportPath;
+  let jsonReportPath;
+  for (const arg of argv) {
+    if (arg.startsWith("--iterations=")) {
+      const value = Number(arg.slice("--iterations=".length));
+      if (Number.isFinite(value) && value > 0) {
+        iterations = value;
+      }
+    } else if (arg.startsWith("--report=")) {
+      reportPath = resolve(process.cwd(), arg.slice("--report=".length));
+    } else if (arg.startsWith("--json-report=")) {
+      const value = arg.slice("--json-report=".length);
+      jsonReportPath = value === "off" ? false : resolve(process.cwd(), value);
+    }
+  }
+  const parsed = iterations === undefined ? { reportPath } : { iterations, reportPath };
+  return jsonReportPath === undefined ? parsed : { ...parsed, jsonReportPath };
+}
+export async function writeBenchmarkReportPair(options) {
+  await mkdir(dirname(options.markdownReportPath), { recursive: true });
+  await writeFile(options.markdownReportPath, options.renderMarkdown(options.report), "utf8");
+  if (options.jsonReportPath === false) {
+    return { markdown: options.markdownReportPath };
+  }
+  if (options.jsonReportPath) {
+    await mkdir(dirname(options.jsonReportPath), { recursive: true });
+    await writeFile(options.jsonReportPath, `${JSON.stringify(options.report, null, 2)}\n`, "utf8");
+    return { markdown: options.markdownReportPath, json: options.jsonReportPath };
+  }
+  return { markdown: options.markdownReportPath };
+}
+function roundPercent(value) {
+  return Math.round(value * 100) / 100;
+}

package/router/dist/benchmarks/benchmarks.d.ts

@@ -0,0 +1,109 @@
+export interface RunRouterBenchmarksOptions {
+  iterations?: number;
+  generatedAt?: string;
+}
+export interface RouterBenchmarkReport {
+  generatedAt: string;
+  iterations: number;
+  summary: RouterBenchmarkSummary;
+  fixtures: RouterBenchmarkFixtureResult[];
+  skippedExternalTools: SkippedExternalTool[];
+}
+export interface RouterBenchmarkSummary {
+  fixtures: number;
+  modeResults: number;
+  improved: ModeSummary;
+  nativeBaseline: ModeSummary;
+  freeflowBaseline: ModeSummary;
+  generatedFalsePositiveCount: number;
+  sandboxFailureFixed: boolean;
+}
+export interface ModeSummary {
+  passed: number;
+  failed: number;
+  skipped: number;
+  pathCorrect: number;
+  spanCorrect: number;
+  excerptComplete: number;
+  generatedFalsePositiveCount: number;
+  totalRawBytes: number;
+  totalRoutedBytes: number;
+  totalRawTokensApprox: number;
+  totalRoutedTokensApprox: number;
+  weightedByteReductionPercent: number;
+  weightedTokenReductionPercent: number;
+  averageByteReductionPercent: number;
+  medianByteReductionPercent: number;
+  averageTokenReductionPercent: number;
+  medianTokenReductionPercent: number;
+}
+export interface RouterBenchmarkFixtureResult {
+  id: string;
+  title: string;
+  kind: BenchmarkKind;
+  expected: BenchmarkExpected;
+  results: RouterBenchmarkModeResult[];
+}
+export interface RouterBenchmarkModeResult {
+  mode: BenchmarkMode;
+  toolPathUsed: string;
+  skipped: boolean;
+  skipReason?: string;
+  rawBytes: number;
+  rawTokensApprox: number;
+  routedBytes: number;
+  routedTokensApprox: number;
+  byteReductionPercent: number;
+  tokenReductionPercent: number;
+  latencyMs: {
+    p50: number;
+    p95: number;
+  };
+  actualPath?: string;
+  actualLines?: string;
+  correctness: CorrectnessResult;
+  recovery: RecoveryResult;
+  notes: string[];
+}
+export interface BenchmarkExpected {
+  path?: string;
+  pathIncludes?: string;
+  lines?: string;
+  requiredExcerpt?: string[];
+}
+export interface CorrectnessResult {
+  passed: boolean;
+  pathCorrect: boolean;
+  spanCorrect: boolean;
+  excerptComplete: boolean;
+  generatedFalsePositive: boolean;
+}
+export interface RecoveryResult {
+  status: "passed" | "failed" | "not-applicable" | "skipped";
+  detail: string;
+}
+export interface SkippedExternalTool {
+  name: string;
+  reason: string;
+}
+type BenchmarkKind = "repo-query" | "repo-expand" | "vault-query";
+type BenchmarkMode = "native-baseline-proxy" | "pre-hardening-freeflow-proxy" | "improved-freeflow-router";
+export declare function runRouterBenchmarks(options?: RunRouterBenchmarksOptions): Promise<RouterBenchmarkReport>;
+export declare function renderRouterBenchmarkReport(report: RouterBenchmarkReport): string;
+export declare function writeRouterBenchmarkReport(report: RouterBenchmarkReport, reportPath: string): Promise<void>;
+export declare function writeRouterBenchmarkJsonReport(
+  report: RouterBenchmarkReport,
+  reportPath: string,
+): Promise<void>;
+export interface WriteRouterBenchmarkReportsOptions {
+  jsonReportPath?: string | false;
+}
+export declare function writeRouterBenchmarkReports(
+  report: RouterBenchmarkReport,
+  markdownReportPath: string,
+  options?: WriteRouterBenchmarkReportsOptions,
+): Promise<{
+  markdown: string;
+  json?: string;
+}>;
+export {};