mirror of
https://github.com/fabro-sh/fabro.git
synced 2026-11-17 09:31:45 +00:00
## Summary
Implements the React Effects Policy by creating the approved hook
surface in `hooks/effects.ts` and migrating a broad set of direct
`useEffect` calls across the codebase to either purpose-named hooks or
non-effect patterns.
### Plan Summary
- Add `hooks/effects.ts` exporting `useMountEffect`, `useInterval`,
`useTimeout`, `useDebouncedValue`, `useWindowEvent`, `useDocumentEvent`,
`useDocumentTitle`, `useMediaQuery`, `useLocationHash`, and
`useResizeObserver`
- Extract large imperative effects into purpose-named hooks:
`useTerminalSession`, `useFloatingTooltipMeasurements`,
`useAnnotatedRunGraphSvg`, `useInstallEffects`, and others
- Move install session fetch from a component effect into a SWR query
(`install-query.ts`)
- Replace `useEffect` + `useState` state-derivation patterns with
render-time computation or ref callbacks
- Replace `AskFabroLayoutProvider`/`useAskFabroLayout` context with a
prop callback
## What changed and why
**`hooks/effects.ts`** — the new approved primitive surface. All
internal `useEffect` calls here are intentional; the hooks expose the
*external system* they manage rather than leaking `useEffect` to
component code. `useMediaQuery` and `useLocationHash` use
`useSyncExternalStore` instead of effect + state.
**`useTerminalSession`** — the largest extraction. The 130-line
xterm/WebSocket/ResizeObserver setup block moves from
`terminal-view.tsx` into its own hook, which now owns the `terminalRef`,
`fitRef`, and `socketRef` that previously cluttered the component.
`TerminalConnectionError` and `ConnectionStatus` types are exported from
the hook.
**`useFloatingTooltipMeasurements`** — extracts the `useLayoutEffect` +
ResizeObserver + window resize listener out of `FloatingTooltip`. The
`FloatingTooltipSize` type moves with it so consumers don't need to
import from the component.
**`useInstallSessionQuery` + `useInstallEffects`** — the install session
fetch moves from a component effect to SWR (`install-query.ts`). The
three remaining install effects (token URL scrubbing, GitHub error URL
scrubbing, health-poll restart) move into
`hooks/use-install-effects.ts`. The root-redirect effect is replaced
with a render-time `<Navigate>` gate. The `SessionState` discriminant
now carries `token` so stale query results can be discarded without an
effect chain.
**`SelectionCheckbox`** — `useEffect` setting `input.indeterminate` is
replaced with a ref callback, which runs synchronously after the node is
attached and avoids a stale-frame flash.
**`event-debug.tsx`** — the manual `window.addEventListener("keydown",
...)` pattern is replaced with `useWindowEvent`, removing the
`react-doctor-disable` suppression comments.
**`run-waterfall.tsx`** — the local `useTickingNow` is deleted;
`RunWaterfall` now calls the shared `useTickingNow` from `lib/time` with
the new `active` parameter signature.
**`toast.test.tsx`** — `useEffect(() => onReady?.(api), ...)` in the
test helper is replaced with a direct call during render, which is valid
because `onReady` has no side effects that React cares about.
**`AskFabroSidebar`** — `setIsResizing` from the layout context is
replaced with an `onResizeActiveChange` prop, removing the
`useAskFabroLayout` call and the hidden context coupling from the
sidebar.
### Fabro Details
<details>
<summary>Ran 3 stages in 114m 5s for $95.71</summary>
| Stage | Duration | Cost | Retries |
|---|---|---|---|
| start | 0s | – | 0 |
| work | 103m 3s | $80.42 | 0 |
| audit | 10m 19s | $15.29 | 0 |
| **Total** | **114m 5s** | **$95.71** | **0** |
</details>
<details>
<summary>Ran <code>Goal.fabro</code> (4 nodes and 5 edges)</summary>
```dot
digraph Goal {
graph [
goal="Complete the user-provided goal",
rankdir=LR,
max_node_visits=30
]
start [shape=Mdiamond, label="Start"]
exit [shape=Msquare, label="Exit"]
work [
label="Work",
thread_id="goal",
fidelity="full",
max_visits=12,
model="gpt-55",
reasoning_effort="xhigh",
prompt="@prompts/continue.md"
]
audit [
label="Completion Audit",
thread_id="goal",
fidelity="full",
goal_gate=true,
retry_target="work",
output_schema="routing",
output_retries=2,
max_visits=12,
model="gpt-55",
reasoning_effort="xhigh",
prompt="@prompts/audit.md"
]
start -> work -> audit
audit -> exit [label="Done", condition="outcome=succeeded"]
audit -> work [label="Continue", condition="outcome=failed || preferred_label=Continue"]
audit -> work [label="No clear verdict"]
}
```
</details>
⚒️ Generated with [Fabro](https://fabro.sh)
---------
Co-authored-by: Fabro <noreply@fabro.sh>
Co-authored-by: Bryan Helmkamp <bryan@brynary.com>
116 lines
4 KiB
TypeScript
116 lines
4 KiB
TypeScript
import { useCallback, useEffect, useRef, useState } from "react";
|
|
|
|
export interface QueryResult {
|
|
columns: string[];
|
|
rows: Array<Record<string, string | number>>;
|
|
elapsed: number;
|
|
rowsRead: number;
|
|
bytesRead: number;
|
|
rowsReturned: number;
|
|
}
|
|
|
|
function generateMockResult(sql: string): QueryResult {
|
|
const lowerSql = sql.toLowerCase();
|
|
|
|
if (lowerSql.includes("workflow_name") && lowerSql.includes("avg")) {
|
|
return {
|
|
columns: ["workflow_name", "avg_duration", "run_count"],
|
|
rows: [
|
|
{ workflow_name: "Expand Product", avg_duration: 342.5, run_count: 48 },
|
|
{ workflow_name: "Implement Feature", avg_duration: 287.3, run_count: 156 },
|
|
{ workflow_name: "Security Scan", avg_duration: 198.1, run_count: 312 },
|
|
{ workflow_name: "Fix Build", avg_duration: 145.7, run_count: 482 },
|
|
{ workflow_name: "Sync Drift", avg_duration: 89.2, run_count: 94 },
|
|
{ workflow_name: "Dependency Audit", avg_duration: 67.4, run_count: 201 },
|
|
],
|
|
elapsed: 0.531,
|
|
rowsRead: 5182366,
|
|
bytesRead: 357780000,
|
|
rowsReturned: 6,
|
|
};
|
|
}
|
|
|
|
if (lowerSql.includes("failure_rate") || lowerSql.includes("failed")) {
|
|
return {
|
|
columns: ["day", "failures", "total", "failure_rate"],
|
|
rows: Array.from({ length: 14 }, (_, i) => {
|
|
const d = new Date();
|
|
d.setDate(d.getDate() - i);
|
|
const total = 80 + Math.floor(Math.random() * 60);
|
|
const failures = Math.floor(Math.random() * 15);
|
|
return {
|
|
day: d.toISOString().slice(0, 10),
|
|
failures,
|
|
total,
|
|
failure_rate: Math.round((1000 * failures) / total) / 10,
|
|
};
|
|
}),
|
|
elapsed: 0.287,
|
|
rowsRead: 2841092,
|
|
bytesRead: 198400000,
|
|
rowsReturned: 14,
|
|
};
|
|
}
|
|
|
|
return {
|
|
columns: ["repo", "runs", "total_additions", "total_deletions"],
|
|
rows: [
|
|
{ repo: "fabro-engine", runs: 482, total_additions: 28450, total_deletions: 12300 },
|
|
{ repo: "fabro-web", runs: 356, total_additions: 19200, total_deletions: 8900 },
|
|
{ repo: "fabro-cli", runs: 198, total_additions: 8700, total_deletions: 4200 },
|
|
{ repo: "fabro-docs", runs: 145, total_additions: 12100, total_deletions: 3400 },
|
|
{ repo: "fabro-sdk", runs: 89, total_additions: 5600, total_deletions: 2100 },
|
|
{ repo: "fabro-infra", runs: 67, total_additions: 3200, total_deletions: 1800 },
|
|
{ repo: "fabro-actions", runs: 42, total_additions: 2100, total_deletions: 980 },
|
|
{ repo: "fabro-proto", runs: 28, total_additions: 1400, total_deletions: 650 },
|
|
],
|
|
elapsed: 0.148,
|
|
rowsRead: 1204588,
|
|
bytesRead: 89200000,
|
|
rowsReturned: 8,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Synchronizes the mock Insights query runner with the browser timer queue.
|
|
* Starting a new run clears any pending timer, and the active timer is cleared
|
|
* on unmount so stale completions cannot update React state.
|
|
*/
|
|
export function useInsightsQueryRunner(initialSql: string) {
|
|
const [result, setResult] = useState<QueryResult | null>(() =>
|
|
generateMockResult(initialSql),
|
|
);
|
|
const [isRunning, setIsRunning] = useState(false);
|
|
const runRequestIdRef = useRef(0);
|
|
const runTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
|
|
|
|
const clearPendingRun = useCallback(() => {
|
|
if (runTimeoutRef.current !== null) {
|
|
clearTimeout(runTimeoutRef.current);
|
|
runTimeoutRef.current = null;
|
|
}
|
|
}, []);
|
|
|
|
const runQuery = useCallback((sql: string) => {
|
|
const requestId = runRequestIdRef.current + 1;
|
|
runRequestIdRef.current = requestId;
|
|
clearPendingRun();
|
|
setIsRunning(true);
|
|
const delay = 200 + Math.random() * 400;
|
|
runTimeoutRef.current = setTimeout(() => {
|
|
if (runRequestIdRef.current !== requestId) return;
|
|
runTimeoutRef.current = null;
|
|
setResult(generateMockResult(sql));
|
|
setIsRunning(false);
|
|
}, delay);
|
|
}, [clearPendingRun]);
|
|
|
|
useEffect(() => {
|
|
return () => {
|
|
runRequestIdRef.current += 1;
|
|
clearPendingRun();
|
|
};
|
|
}, [clearPendingRun]);
|
|
|
|
return { result, isRunning, runQuery };
|
|
}
|