@oqtopus-team/pi-qdash 0.1.2 → 0.1.4

package/extensions/lib/timeseries-plot.ts

@@ -0,0 +1,101 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+
+import { firstString } from "./payload.js";
+import { ansi, boxed, compactDate, formatNumber } from "./render.js";
+
+export type TimeseriesPoint = {
+  series: string;
+  value: number;
+  at?: string;
+  unit?: string;
+  taskId?: string;
+  executionId?: string;
+};
+
+export function timeseriesPoints(payload: unknown): TimeseriesPoint[] {
+  const points: TimeseriesPoint[] = [];
+  const addPoint = (series: string, item: unknown) => {
+    if (!item || typeof item !== "object") return;
+    const object = item as Record<string, unknown>;
+    const value = object.value;
+    if (typeof value !== "number" || !Number.isFinite(value)) return;
+    points.push({
+      series,
+      value,
+      at: firstString(object, ["calibrated_at", "timestamp", "created_at", "start_at"]),
+      unit: firstString(object, ["unit"]),
+      taskId: firstString(object, ["task_id"]),
+      executionId: firstString(object, ["execution_id"]),
+    });
+  };
+  const visit = (value: unknown, series = "series") => {
+    if (Array.isArray(value)) {
+      for (const item of value) addPoint(series, item);
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    const object = value as Record<string, unknown>;
+    if ("value" in object) {
+      addPoint(series, object);
+      return;
+    }
+    for (const [key, nested] of Object.entries(object)) visit(nested, key);
+  };
+  if (payload && typeof payload === "object" && "data" in payload) visit((payload as Record<string, unknown>).data);
+  else visit(payload);
+  return points.sort((a, b) => (a.at ?? "").localeCompare(b.at ?? ""));
+}
+
+function samplePoints(points: TimeseriesPoint[], width: number): TimeseriesPoint[] {
+  if (points.length <= width) return points;
+  const sampled: TimeseriesPoint[] = [];
+  for (let i = 0; i < width; i++) sampled.push(points[Math.round(i * (points.length - 1) / (width - 1))]);
+  return sampled;
+}
+
+export function plotSeriesLines(points: TimeseriesPoint[], options: { title: string; height?: number; width?: number; color?: boolean }): string[] {
+  const height = Math.max(3, Math.min(20, options.height ?? 8));
+  const plotWidth = Math.max(8, Math.min(100, options.width ?? 60));
+  const accent = (text: string) => options.color ? ansi("1;36", text) : text;
+  const muted = (text: string) => options.color ? ansi("90", text) : text;
+  if (points.length === 0) return boxed(options.title, [muted("no numeric data")], options.color);
+
+  const sampled = samplePoints(points, plotWidth);
+  const values = sampled.map((point) => point.value);
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const span = max - min || 1;
+  const grid = Array.from({ length: height }, () => Array.from({ length: sampled.length }, () => " "));
+  sampled.forEach((point, col) => {
+    const row = height - 1 - Math.round((point.value - min) / span * (height - 1));
+    grid[Math.max(0, Math.min(height - 1, row))][col] = "●";
+  });
+  const yLabelWidth = Math.max(formatNumber(max).length, formatNumber(min).length, 6);
+  const rows = grid.map((row, index) => {
+    const value = max - (span * index / (height - 1));
+    return `${formatNumber(value).padStart(yLabelWidth)} ┤${row.join("")}`;
+  });
+  const unit = points.find((point) => point.unit)?.unit;
+  const first = points[0];
+  const last = points[points.length - 1];
+  const body = [
+    `${muted("series")} ${accent([...new Set(points.map((point) => point.series))].join(", "))}${unit ? `  ${muted("unit")} ${unit}` : ""}`,
+    `${muted("count")} ${points.length}  ${muted("min")} ${formatNumber(Math.min(...points.map((point) => point.value)))}  ${muted("max")} ${formatNumber(Math.max(...points.map((point) => point.value)))}  ${muted("last")} ${formatNumber(last.value)}`,
+    `${muted("range")} ${compactDate(first.at)} → ${compactDate(last.at)}`,
+    "",
+    ...rows,
+    `${" ".repeat(yLabelWidth)} └${"─".repeat(sampled.length)}`,
+  ];
+  return boxed(options.title, body, options.color);
+}
+
+export function timeseriesPlotComponent(data: unknown, title: string, _theme: Theme) {
+  return {
+    render(width: number) {
+      const points = timeseriesPoints(data);
+      return plotSeriesLines(points, { title, width: Math.max(8, width - 16) }).map((line) => truncateToWidth(line, width));
+    },
+    invalidate() {},
+  };
+}

package/extensions/lib/wiring-analysis.ts

@@ -0,0 +1,169 @@
+export type AttenuationEntry = {
+  mux: string;
+  line: "control" | "readout_send";
+  totalDb: number;
+  components: number[];
+  panel?: string;
+  hardwarePort?: string;
+  qid?: string;
+};
+
+export type WiringInsights = {
+  entries: AttenuationEntry[];
+  control: { commonTotalDb?: number; anomalies: AttenuationEntry[]; totals: Record<string, number> };
+  readoutSend: { commonTotalDb?: number; anomalies: AttenuationEntry[]; totals: Record<string, number> };
+  suggestions: string[];
+};
+
+function ansi(code: string, text: string): string {
+  return `\u001b[${code}m${text}\u001b[0m`;
+}
+
+function boxed(title: string, body: string[], color = false): string[] {
+  const rawLines = [` ${title} `, ...body];
+  const width = Math.min(100, Math.max(...rawLines.map((line) => line.replace(/\u001b\[[0-9;]*m/g, "").length), title.length + 4));
+  const border = (text: string) => color ? ansi("90", text) : text;
+  const top = `${border("╭")}${color ? ansi("1;36", ` ${title} `) : ` ${title} `}${border("─".repeat(Math.max(0, width - title.length - 2)))}${border("╮")}`;
+  const bottom = border(`╰${"─".repeat(width)}╯`);
+  const middle = body.map((line) => `│ ${line}${" ".repeat(Math.max(0, width - line.replace(/\u001b\[[0-9;]*m/g, "").length - 2))} │`);
+  return [top, ...middle, bottom];
+}
+
+function markdownTableRows(markdown: string): string[][] {
+  return markdown.split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("|") && line.endsWith("|"))
+    .map((line) => line.slice(1, -1).split("|").map((cell) => cell.trim()))
+    .filter((cells) => cells.length >= 7 && !cells.every((cell) => /^-+$/.test(cell.replace(/\s/g, ""))));
+}
+
+function expandPanelSpec(value: string): string[] {
+  return value.split(/[、,]/).flatMap((part) => {
+    const token = part.trim();
+    if (!token) return [];
+    const range = token.match(/^([A-Za-z]+)(\d+)\s*-\s*(\d+)$/);
+    if (range) {
+      const [, prefix, startText, endText] = range;
+      const start = Number(startText);
+      const end = Number(endText);
+      const step = start <= end ? 1 : -1;
+      const panels: string[] = [];
+      for (let value = start; step > 0 ? value <= end : value >= end; value += step) panels.push(`${prefix}${value}`);
+      return panels;
+    }
+    return [token];
+  });
+}
+
+function splitPortsAndPanels(cell: string): { ports: string[]; panels: string[] } {
+  const [portsText = cell, panelsText = ""] = cell.split(/\s+\/\s+/, 2);
+  return {
+    ports: portsText.split(/[、,]/).map((part) => part.trim()).filter(Boolean),
+    panels: expandPanelSpec(panelsText),
+  };
+}
+
+function attenuationNumbers(text: string): number[] {
+  return [...text.matchAll(/(?:追加\s*)?(\d+(?:\.\d+)?)\s*dB/gi)].map((match) => Number(match[1])).filter(Number.isFinite);
+}
+
+function panelAttenuationTotals(cell: string): Array<{ panels?: string[]; components: number[]; totalDb: number }> {
+  const parenthesized = [...cell.matchAll(/([^（）]+)（([^）]+)）/g)].map((match) => {
+    const components = attenuationNumbers(match[1]);
+    return { panels: expandPanelSpec(match[2]), components, totalDb: components.reduce((sum, value) => sum + value, 0) };
+  }).filter((segment) => segment.components.length > 0);
+  if (parenthesized.length > 0) return parenthesized;
+  const components = attenuationNumbers(cell);
+  return components.length > 0 ? [{ components, totalDb: components.reduce((sum, value) => sum + value, 0) }] : [];
+}
+
+function mostCommonTotal(entries: AttenuationEntry[]): number | undefined {
+  const counts = new Map<number, number>();
+  for (const entry of entries) counts.set(entry.totalDb, (counts.get(entry.totalDb) ?? 0) + 1);
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0] - b[0])[0]?.[0];
+}
+
+function totalHistogram(entries: AttenuationEntry[]): Record<string, number> {
+  const histogram: Record<string, number> = {};
+  for (const entry of entries) histogram[String(entry.totalDb)] = (histogram[String(entry.totalDb)] ?? 0) + 1;
+  return histogram;
+}
+
+export function analyzeWiringMarkdown(markdown: string | undefined): WiringInsights | undefined {
+  if (!markdown) return undefined;
+  const rows = markdownTableRows(markdown);
+  const dataRows = rows.filter((cells) => /^\d+$/.test(cells[0]));
+  const entries: AttenuationEntry[] = [];
+  for (const cells of dataRows) {
+    const mux = cells[0].padStart(2, "0");
+    const muxNumber = Number(cells[0]);
+    const control = splitPortsAndPanels(cells[1] ?? "");
+    const controlSegments = panelAttenuationTotals(cells[5] ?? "");
+    for (let index = 0; index < control.panels.length; index++) {
+      const panel = control.panels[index];
+      const segment = controlSegments.find((item) => item.panels?.includes(panel)) ?? (controlSegments.length === 1 ? controlSegments[0] : undefined);
+      if (!segment) continue;
+      entries.push({
+        mux,
+        line: "control",
+        panel,
+        hardwarePort: control.ports[index],
+        qid: Number.isFinite(muxNumber) ? String(muxNumber * 4 + index) : undefined,
+        totalDb: segment.totalDb,
+        components: segment.components,
+      });
+    }
+    const readoutSegments = panelAttenuationTotals(cells[6] ?? "");
+    const readout = splitPortsAndPanels(cells[2] ?? "");
+    if (readoutSegments[0]) {
+      entries.push({
+        mux,
+        line: "readout_send",
+        panel: readout.panels[0],
+        hardwarePort: readout.ports[0],
+        totalDb: readoutSegments[0].totalDb,
+        components: readoutSegments[0].components,
+      });
+    }
+  }
+  const controlEntries = entries.filter((entry) => entry.line === "control");
+  const readoutEntries = entries.filter((entry) => entry.line === "readout_send");
+  const controlCommon = mostCommonTotal(controlEntries);
+  const readoutCommon = mostCommonTotal(readoutEntries);
+  const controlAnomalies = controlCommon === undefined ? [] : controlEntries.filter((entry) => entry.totalDb !== controlCommon);
+  const readoutAnomalies = readoutCommon === undefined ? [] : readoutEntries.filter((entry) => entry.totalDb !== readoutCommon);
+  const suggestions = [
+    controlCommon !== undefined ? `Control の最頻総減衰量は ${controlCommon} dB です。` : undefined,
+    controlAnomalies.length > 0
+      ? `Control で最頻値と異なるポートが ${controlAnomalies.length} 件あります: ${controlAnomalies.map((entry) => entry.qid ? `q${entry.qid}` : `${entry.mux}/${entry.panel}`).join(", ")}`
+      : controlEntries.length > 0 ? "Control の総減衰量は全ポートで揃っています。" : undefined,
+    readoutCommon !== undefined ? `Readout send の最頻総減衰量は ${readoutCommon} dB です。` : undefined,
+    readoutAnomalies.length > 0
+      ? `Readout send で最頻値と異なる MUX が ${readoutAnomalies.length} 件あります: ${readoutAnomalies.map((entry) => `MUX${entry.mux}`).join(", ")}`
+      : readoutEntries.length > 0 ? "Readout send の総減衰量は全 MUX で揃っています。" : undefined,
+  ].filter((line): line is string => Boolean(line));
+  return {
+    entries,
+    control: { commonTotalDb: controlCommon, anomalies: controlAnomalies, totals: totalHistogram(controlEntries) },
+    readoutSend: { commonTotalDb: readoutCommon, anomalies: readoutAnomalies, totals: totalHistogram(readoutEntries) },
+    suggestions,
+  };
+}
+
+export function wiringInsightLines(insights: WiringInsights, color = false): string[] {
+  const accent = (text: string) => color ? ansi("1;36", text) : text;
+  const muted = (text: string) => color ? ansi("90", text) : text;
+  const warning = (text: string) => color ? ansi("33", text) : text;
+  const formatEntry = (entry: AttenuationEntry) => `${entry.qid ? `q${entry.qid}` : `MUX${entry.mux}`} ${muted(`MUX${entry.mux}`)} ${entry.panel ?? ""}${entry.hardwarePort ? `/${entry.hardwarePort}` : ""}: ${warning(`${entry.totalDb} dB`)} (${entry.components.join("+")})`;
+  return boxed("QDash Wiring Insights", [
+    ...insights.suggestions.map((line) => `• ${line}`),
+    "",
+    accent("Control totals"),
+    `  ${Object.entries(insights.control.totals).map(([total, count]) => `${total} dB × ${count}`).join(", ") || muted("none")}`,
+    ...(insights.control.anomalies.length > 0 ? ["", accent("Control anomalies"), ...insights.control.anomalies.map((entry) => `  ${formatEntry(entry)}`)] : []),
+    "",
+    accent("Readout send totals"),
+    `  ${Object.entries(insights.readoutSend.totals).map(([total, count]) => `${total} dB × ${count}`).join(", ") || muted("none")}`,
+    ...(insights.readoutSend.anomalies.length > 0 ? ["", accent("Readout send anomalies"), ...insights.readoutSend.anomalies.map((entry) => `  ${formatEntry(entry)}`)] : []),
+  ], color);
+}

package/extensions/lib/write-gate.ts

@@ -0,0 +1,35 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const WRITE_TOOL_NAMES = new Set([
+  "qdash_create_agent_session",
+  "qdash_submit_agent_action",
+  "qdash_commit_agent_candidate",
+  "qdash_execute_agent_action",
+  "qdash_commit_agent_campaign_candidates",
+  "qdash_apply_agent_candidate_commit",
+  "qdash_create_forum_post",
+  "qdash_update_forum_post",
+  "qdash_create_forum_evidence_reply",
+]);
+
+export function installQDashWriteGate(pi: ExtensionAPI): void {
+  pi.on("tool_call", async (event, ctx) => {
+    if (!WRITE_TOOL_NAMES.has(event.toolName)) return;
+    const input = event.input as { confirmWrite?: boolean };
+    if (input.confirmWrite === true) return;
+
+    if (!ctx.hasUI) {
+      return {
+        block: true,
+        reason: `${event.toolName} is a QDash write operation and requires confirmWrite: true in non-interactive mode.`,
+      };
+    }
+
+    const ok = await ctx.ui.confirm(
+      "Approve QDash write operation?",
+      `${event.toolName} will create or modify data in QDash. Continue?`,
+    );
+    if (!ok) return { block: true, reason: "QDash write operation rejected by user" };
+    input.confirmWrite = true;
+  });
+}