Typescript products

This repo is only for v1 and supports Bilibil and YouTube! 🤖 BibiGPT: one-Click AI Summary for Audio/Video & Chat with Learning Content https://bibigpt.co 🎉 Effortlessly summarize YouTube and Bilibili videos with our AI-driven Video Summarizer. It also works for Podcasts, Twitter, Meetings, Lectures, Tiktok videos, and more. Discover a more brilliant way to learn with ChatGPT, your best AI-powered study companion! (formerly BiliGPT) "stream-saving artifact & class representative". Alternate address: https://b.jimmylv.cn Browser extension: https://bibigpt.co/extension 🤖 BibiGPT · AI 音视频内容一键总结 & 对话 https://bibigpt.co 🎉 ChatGPT AI 音视频一键总结，轻松学习哔哩哔哩丨 YouTube 丨本地视频丨本地音频丨播客丨小红书丨抖音丨会议丨讲座丨网页等任意内容。BibiGPT 助力于成为最好的 AI 学习助理，支持免费试用！(原 BiliGPT 省流神器 & AI 课代表)（支持 iOS 快捷指令 & 微信服务号）。备用地址：https://b.jimmylv.cn 浏览器插件: https://bibigpt.co/extension 🎬 This project summarizes YouTube/Bilibili/Twitter/TikTok/Podcast/Lecture/Meeting/... videos or audios for you using AI. 🤯 Inspired by Nutlope/news-summarizer & zhengbangbo/chat-simplifier & lxfater/BilibiliSummary 🚀 First Launch: 【BibiGPT】AI 自动总结 B 站视频内容，GPT-3 智能提取并总结字幕 How it works This project uses the AI SDK OpenAI-compatible provider with Vercel Edge functions for streaming, plus Upstash for Redis cache and rate limiting. It fetches the content on a Bilibili video, sends it in a prompt to an OpenAI-compatible API, then streams the response back to the application. Saving costs Projects like this can get expensive so in order to save costs if you want to make your own version and share it publicly, I recommend three things: 1. Implement rate limiting so people can't abuse your site 2. Implement caching to avoid expensive AI re-generations 3. Use text-curie-001 instead of text-dacinci-003 in the summarize edge function Running Locally After cloning the repo, go to OpenAI to make an account and put your API key in a file called .env. Then, run the application in the command line and it will be available at http://localhost:3000. specific running procedure is described in this document - Chinese version npm run dev Deployment Deploy the example using Vercel Setup the env variables, by following the ./example.env file. Support Docker #133 # make sure setup .env file firstly docker compose up -d Support -> Contact Me

chwire ClickHouse HTTP/TCP client and Native wire format toolkit for TypeScript. Install npm install @maxjustus/chwire HTTP vs TCP TCP works better for long-running queries and gives you streaming telemetry (progress, logs, profile events). HTTP works anywhere (including browsers) and supports all ClickHouse input/output formats. Quick Start HTTP Client The HTTP client is stateless — query() and insert() are standalone functions that each make a single HTTP request. import { insert, query, streamEncodeJsonEachRow, collectText } from "@maxjustus/chwire"; const connectionConfig = { url: "http://localhost:8123/", auth: { username: "default", password: "" }, }; // Insert const { summary } = await insert( "INSERT INTO table FORMAT JSONEachRow", streamEncodeJsonEachRow([{ id: 1, name: "test" }]), connectionConfig, ); console.log(`Wrote ${summary.written_rows} rows`); // Query const json = await collectText(query("SELECT * FROM table FORMAT JSON", connectionConfig)); // DDL await query("CREATE TABLE ...", connectionConfig); TCP Client import { TcpClient } from "@maxjustus/chwire/tcp"; const client = new TcpClient({ host: "localhost", port: 9000 }); await client.connect(); // Query for await (const packet of client.query("SELECT * FROM table")) { if (packet.type === "Data") { for (const row of packet.batch) console.log(row.id, row.name); } } // Insert await client.insert("INSERT INTO table", [{ id: 1, name: "alice" }]); client.close(); HTTP Client query() returns a CollectableAsyncGenerator that yields Data packets (raw Uint8Array chunks), Progress packets, and a final Summary. Use await to collect all packets into an array, or pipe through helpers like collectText and streamDecodeJsonEachRow which consume the Data chunks for you. insert() returns Promise<InsertResult> — an object with summary (containing written_rows, written_bytes, elapsed_ns, etc.) and queryId. Query Parameters const result = await collectText( query("SELECT {id: UInt64} as id, {name: String} as name FORMAT JSON", { ...connectionConfig, params: { id: 42, name: "Alice" }, }), ); Parameters are type-safe and prevent SQL injection. The type annotation (e.g., {name: String}) tells ClickHouse how to parse the value. Placeholders without a supplied value are sent as-is and resolved by the server. This makes parameterized-view DDL and session-level SET param_x = ... bindings work; a genuinely unbound parameter fails server-side with UNKNOWN_QUERY_PARAMETER. Unknown root-level option keys are forwarded as raw ClickHouse URL params: const result = await collectText(query("SELECT 42 as value", { ...connectionConfig, default_format: "TSV", wait_end_of_query: 1, })); The transport keys url, auth, compression, compressQuery, signal, timeout, clientVersion, settings, params, externalTables, queryId, and sessionId are reserved and are not forwarded as raw URL params. Parsing Query Results The query() function yields raw Uint8Array chunks aligned to compression blocks, not rows. Use helpers to parse: import { query, streamText, streamLines, streamDecodeJsonEachRow, collectJsonEachRow, collectText, collectBytes, } from "@maxjustus/chwire"; // JSONEachRow - streaming parsed objects for await (const row of streamDecodeJsonEachRow( query("SELECT * FROM t FORMAT JSONEachRow", connectionConfig), )) { console.log(row.id, row.name); } const res = await collectJsonEachRow( query("SELECT * FROM t FORMAT JSONEachRow", connectionConfig), ); // CSV/TSV - streaming raw lines for await (const line of streamLines( query("SELECT * FROM t FORMAT CSV", connectionConfig), )) { const [id, name] = line.split(","); } // JSON format - buffer entire response const json = await collectText( query("SELECT * FROM t FORMAT JSON", connectionConfig), ); const data = JSON.parse(json); Streaming Large Inserts The HTTP insert function accepts Uint8Array, Uint8Array[], or AsyncIterable<Uint8Array>. Use streamEncodeJsonEachRow for JSON data: // Streaming JSON objects async function* generateRows() { for (let i = 0; i < 1000000; i++) { yield { id: i, value: `data_${i}` }; } } await insert( "INSERT INTO large_table FORMAT JSONEachRow", streamEncodeJsonEachRow(generateRows()), { ...connectionConfig, compression: { method: "zstd", level: 6 }, onProgress: (p) => console.log(`${p.bytesUncompressed} bytes`), }, ); // Streaming raw bytes (any format) async function* generateCsvChunks() { const encoder = new TextEncoder(); for (let batch = 0; batch < 1000; batch++) { let chunk = ""; for (let i = 0; i < 1000; i++) { chunk += `${batch * 1000 + i},value_${i}\n`; } yield encoder.encode(chunk); } } await insert( "INSERT INTO large_table FORMAT CSV", generateCsvChunks(), { ...connectionConfig, compression: "lz4" }, ); External Tables Send temporary in-memory tables with your query. Schema is auto-extracted from RecordBatch (see Native Format for construction): import { batchFromCols, getCodec, query, collectText } from "@maxjustus/chwire"; const users = batchFromCols({ id: getCodec("UInt32").fromValues(new Uint32Array([1, 2, 3])), name: getCodec("String").fromValues(["Alice", "Bob", "Charlie"]), }); const result = await collectText(query( "SELECT * FROM users WHERE id > 1 FORMAT JSON", { url, auth, externalTables: { users } } )); For raw TSV/CSV/JSON data, use the explicit structure form: const result = await collectText(query( "SELECT * FROM mydata ORDER BY id FORMAT JSON", { url, auth, externalTables: { mydata: { structure: "id UInt32, name String", format: "TabSeparated", // or JSONEachRow, CSV, etc. data: "1\tAlice\n2\tBob\n" } } } )); Timeout and Cancellation Configure with timeout (ms) or provide an AbortSignal for manual cancellation: // Custom timeout await insert(sql, data, { ...connectionConfig, timeout: 60_000 }); // Manual cancellation const controller = new AbortController(); setTimeout(() => controller.abort(), 5000); await insert(sql, data, { ...connectionConfig, signal: controller.signal }); // Both (whichever triggers first) await insert(sql, data, { ...connectionConfig, signal: controller.signal, timeout: 60_000, }); Error Handling The HTTP client throws ClickHouseException for server errors: import { ClickHouseException } from "@maxjustus/chwire"; try { for await (const _ of query("SELECT * FROM nonexistent", config)) {} } catch (err) { if (err instanceof ClickHouseException) { console.log(err.code); // 60 (UNKNOWN_TABLE) console.log(err.exceptionName); // "DB::Exception" console.log(err.message); // "Table ... doesn't exist" } } Insert errors follow the same pattern: try { await insert("INSERT INTO t FORMAT JSONEachRow", data, config); } catch (err) { if (err instanceof ClickHouseException) { console.log(err.code); console.log(err.message); } } TCP Client Uses ClickHouse's native TCP protocol. TCP Single connection per client; use separate clients for concurrent operations. Note that the TCP protocol only sends/recieves data in Native format. Basic Usage import { TcpClient } from "@maxjustus/chwire/tcp"; const client = new TcpClient({ host: "localhost", port: 9000, database: "default", user: "default", password: "", }); await client.connect(); for await (const packet of client.query("SELECT * FROM table")) { if (packet.type === "Data") { for (const row of packet.batch) { console.log(row.id, row.name); } } } // DDL await client.query("CREATE TABLE ..."); // Insert (await collects and discards packets; for progress tracking see "Insert Progress Tracking" below) await client.insert("INSERT INTO table", [{ id: 1, name: "alice" }]); client.close(); TCP connections hold a persistent socket — always call client.close() when done, or use await using for automatic cleanup. Connection Options const client = new TcpClient({ host: "localhost", port: 9000, database: "default", user: "default", password: "", compression: "lz4", // 'lz4' | 'zstd' | false | { method: 'zstd', level: 6 } connectTimeout: 10000, // ms queryTimeout: 30000, // ms tls: true, // or Node.js tls.ConnectionOptions for custom CA/certs. IE: tls: { ca: fs.readFileSync("/path/to/ca.pem"), rejectUnauthorized: true }, }); Streaming Results Query yields packets - handle by type: for await (const packet of client.query(sql, { settings: { send_logs_level: "trace" } })) { switch (packet.type) { case "Data": console.log(`${packet.batch.rowCount} rows`); break; case "Progress": console.log(`${packet.progress.readRows} rows read`); break; case "Log": for (const entry of packet.entries) { console.log(`[${entry.source}] ${entry.text}`); } break; case "ProfileInfo": console.log(`${packet.info.rows} total rows`); break; case "EndOfStream": break; } } Progress Tracking Progress packets contain delta values (increments since the last packet). The client accumulates these into running totals available via packet.accumulated: for await (const packet of client.query(sql)) { if (packet.type === "Progress") { const { accumulated } = packet; console.log(`${accumulated.percent}% complete`); console.log(`Read: ${accumulated.readRows} rows, ${accumulated.readBytes} bytes`); console.log(`Elapsed: ${Number(accumulated.elapsedNs) / 1e9}s`); } } ProfileEvents and Resource Metrics ProfileEvents provide execution metrics. Memory and CPU stats are merged into accumulated progress: for await (const packet of client.query(sql)) { if (packet.type === "Progress") { const { accumulated } = packet; console.log(`Memory: ${accumulated.memoryUsage} bytes`); console.log(`Peak memory: ${accumulated.peakMemoryUsage} bytes`); console.log(`CPU time: ${accumulated.cpuTimeMicroseconds}µs`); console.log(`CPU cores utilized: ${accumulated.cpuUsage.toFixed(1)}`); } if (packet.type === "ProfileEvents") { // Raw accumulated event counters console.log(`Selected rows: ${packet.accumulated.get("SelectedRows")}`); console.log(`Read bytes: ${packet.accumulated.get("ReadCompressedBytes")}`); } } memoryUsage is the latest value; peakMemoryUsage is the max seen. cpuUsage shows equivalent CPUs utilized. Insert API The insert() method accepts RecordBatches or row objects: // Single batch await client.insert("INSERT INTO t", batch); // Multiple batches await client.insert("INSERT INTO t", [batch1, batch2]); // Row objects with auto-coercion. Types are inferred from server schema. // Unknown keys ignored, omitted keys use defaults, incompatible provided types throw. await client.insert("INSERT INTO t", [ { id: 1, name: "alice" }, { id: 2, name: "bob" }, ]); // Streaming rows with generator async function* generateRows() { for (let i = 0; i < 1000000; i++) { yield { id: i, name: `user${i}` }; } } // batchSize dictates number of rows per RecordBatch (native insert block) sent await client.insert("INSERT INTO t", generateRows(), { batchSize: 10000 }); // Schema validation (fail fast if types don't match the schema the server sends for the insert table) await client.insert("INSERT INTO t", rows, { schema: [ { name: "id", type: "UInt32" }, { name: "name", type: "String" }, ], }); Insert Progress Tracking Both query() and insert() return a CollectableAsyncGenerator<Packet>: await gen collects all packets into an array for await streams packets one at a time the same generator instance is single-consumer and does not replay once drained // Collect all packets const packets = await client.insert("INSERT INTO t", rows); const progress = packets.findLast(p => p.type === "Progress"); if (progress?.type === "Progress") { console.log(`Wrote ${progress.accumulated.writtenRows} rows`); } // Stream packets (useful for real-time progress on large inserts) for await (const packet of client.insert("INSERT INTO t", generateRows())) { if (packet.type === "Progress") { console.log(`Written: ${packet.accumulated.writtenRows} rows`); } } Query Parameters for await (const packet of client.query( "SELECT * FROM users WHERE age > {min_age: UInt32}", { params: { min_age: 18 } } )) { /* ... */ } Same {name: Type} syntax as HTTP. Parameters are type-safe and prevent SQL injection. External Tables Pass RecordBatches directly: import { batchFromCols, getCodec } from "@maxjustus/chwire"; const users = batchFromCols({ id: getCodec("UInt32").fromValues(new Uint32Array([1, 2, 3])), name: getCodec("String").fromValues(["Alice", "Bob", "Charlie"]), }); for await (const packet of client.query( "SELECT * FROM users WHERE id > 1", { externalTables: { users } } )) { if (packet.type === "Data") { for (const row of packet.batch) console.log(row.name); } } Supports streaming via iterables/async iterables of RecordBatch: async function* generateBatches() { for (let i = 0; i < 10; i++) { yield batchFromCols({ id: getCodec("UInt32").fromValues([i]) }); } } await client.query("SELECT sum(id) FROM data", { externalTables: { data: generateBatches() } }); Cancellation const controller = new AbortController(); setTimeout(() => controller.abort(), 5000); await client.connect({ signal: controller.signal }); for await (const p of client.query(sql, { signal: controller.signal })) { // ... } Auto-Close on Scope Exit await using client = await TcpClient.connect(options); // automatically closed when scope exits Error Handling The TCP client throws ClickHouseException for server errors: import { TcpClient, ClickHouseException } from "@maxjustus/chwire/tcp"; try { for await (const _ of client.query("SELECT * FROM nonexistent")) {} } catch (err) { if (err instanceof ClickHouseException) { console.log(err.code); // 60 (UNKNOWN_TABLE) console.log(err.exceptionName); // "DB::Exception" console.log(err.message); // "Table ... doesn't exist" console.log(err.serverStackTrace); // Full server-side stack trace console.log(err.nested); // Nested exception if present } } Connection and protocol errors throw JavaScript's built-in Error (not ClickHouseException): try { await client.connect(); } catch (err) { // err.message: "Connection timeout after 10000ms" // err.message: "Not connected" // err.message: "Connection busy - cannot run concurrent operations..." } Native Format Native is ClickHouse's columnar binary wire format. It's generally faster and smaller to serialize/deserialize vs JSON (see Performance below). Data arrives as RecordBatch objects. RecordBatch wraps typed column arrays you can iterate by row or access by column. Use it when throughput matters; use JSON when you want plain objects and don't need the speed.

Record every LLM call, tool invocation, and error your agent makes. Replay it step-by-step like a video. Fork from any point, change the input, and watch the whole agent re-execute down a new path. Share any run as an interactive, public link. Python · TypeScript · How It Works · Docs Python pip install retrace-sdk import retrace retrace.configure(api_key="rt_...") @retrace.record(name="research-agent", resumable=True) def run_agent(prompt: str): plan = call_planner(prompt) # captured automatically results = call_tools(plan) # captured automatically return summarize(results) # captured automatically run_agent("What changed in vector databases this year?") See python/README.md for the full reference. TypeScript npm install retrace-sdk import { configure, trace } from "retrace-sdk"; configure({ apiKey: "rt_..." }); const runAgent = trace(async (prompt: string) => { const plan = await callPlanner(prompt); // captured automatically const results = await callTools(plan); // captured automatically return summarize(results); // captured automatically }, { name: "research-agent", resumable: true }); await runAgent("What changed in vector databases this year?"); See typescript/README.md for the full reference. How It Works The SDK is a thin capture layer. It wraps your function, auto-instruments provider calls (OpenAI, Anthropic, Gemini), and streams spans to Retrace over a resilient transport — never blocking or crashing your agent. flowchart LR subgraph yourproc["Your process"] fn["@record / trace()"] --> cap["auto-captured spans<br/>(LLM · tool · error)"] cap --> buf["offline buffer<br/>(bounded, flush on reconnect)"] end buf == "WebSocket (primary)" ==> api["Retrace"] buf -. "HTTP fallback" .-> api api == "resume: re-execute from fork point" ==> fn classDef p fill:#0f3d2e,stroke:#10b981,color:#d1fae5; class api p; Loading Capture — provider calls are intercepted automatically; you can also emit manual spans. Transport — spans stream over a WebSocket; if it drops, the SDK falls back to HTTP and replays a bounded offline buffer on reconnect, so nothing is lost. Resumable — mark a function resumable and a dashboard fork re-executes it from any step with modified input (cascade replay). Safe by default — failures in the SDK never surface into your agent; typed errors expose real problems explicitly. Documentation Full documentation at docs.retraceai.tech.

The UI framework for coding agents ArrowJS is a tiny, blazing-fast, type-safe reactive UI runtime built around platform primitives that coding agents deeply understand: JavaScript modules, template literals, and the DOM. Use @arrow-js/core when you want direct reactive DOM updates with minimal API surface. Add @arrow-js/framework, @arrow-js/ssr, and @arrow-js/hydrate when you need async components, server-side rendering, and client-side hydration on top of the same component model. Documentation · API Reference · Playground · Discord Core Package @arrow-js/core: reactive state, tagged-template rendering, components, pick() / props(), and nextTick() Framework Packages @arrow-js/framework: async component runtime, boundary(), render(), toTemplate(), and document rendering helpers @arrow-js/ssr: renderToString() and serializePayload() for server output @arrow-js/hydrate: hydrate() and readPayload() for adopting SSR output in the browser @arrow-js/sandbox: QuickJS/WASM-backed sandbox runtime for executing Arrow code off the host window realm while rendering into the real DOM @arrow-js/vite-plugin-arrow: Vite integration package included in the monorepo Install Scaffold a complete Vite 8 Arrow app with SSR, hydration, and the full framework stack: pnpm create arrow-js@latest arrow-app Agent skill: Equip your preferred coding agent to add Arrow to an existing project: npx @arrow-js/skill Core-only: npm install @arrow-js/core Full SSR + hydration stack: pnpm add @arrow-js/core @arrow-js/framework @arrow-js/ssr @arrow-js/hydrate No build step is required for the core runtime. You can also import it directly in the browser: <script type="module"> import { html, reactive } from 'https://esm.sh/@arrow-js/core' </script> Core Example import { component, html, reactive } from '@arrow-js/core' const Counter = component(() => { const state = reactive({ count: 0 }) return html`<button @click="${() => state.count++}"> Clicked ${() => state.count} times </button>` }) html`${Counter()}`(document.body) Async Components, SSR, and Hydration Async components use the same component() API, but they require the async runtime from @arrow-js/framework, @arrow-js/ssr, or @arrow-js/hydrate to be imported before rendering. The current project structure keeps that layering explicit: @arrow-js/core stays DOM-first and framework-agnostic. @arrow-js/framework adds async render tracking and boundaries. @arrow-js/ssr renders HTML and serializes async payloads on the server. @arrow-js/hydrate adopts existing SSR HTML instead of replacing it on the client. Editor Support Install the official ArrowJS Syntax extension for VSCode to get syntax highlighting and autocomplete inside html template literals. Community Discord — ask questions, share what you're building, and connect with other Arrow developers GitHub Issues — report bugs and request features Follow @jpschroeder on X for updates and releases Monorepo Development pnpm dev: run the docs app locally pnpm test: run Vitest pnpm test:e2e: run Playwright tests pnpm typecheck: run TypeScript across the workspace

Antfarm Build your agent team in OpenClaw with one command. You don't need to hire a dev team. You need to define one. Antfarm gives you a team of specialized AI agents — planner, developer, verifier, tester, reviewer — that work together in reliable, repeatable workflows. One install. Zero infrastructure. Install curl -fsSL https://raw.githubusercontent.com/snarktank/antfarm/v0.5.1/scripts/install.sh | bash Or just tell your OpenClaw agent: "install github.com/snarktank/antfarm" That's it. Run antfarm workflow list to see available workflows. Not on npm. Antfarm is installed from GitHub, not the npm registry. There is an unrelated antfarm package on npm — that's not this. Requires Node.js >= 22. If antfarm fails with a node:sqlite error, make sure you're running real Node.js 22+, not Bun's node wrapper (see #54). What You Get: Agent Team Workflows feature-dev 7 agents Drop in a feature request. Get back a tested PR. The planner decomposes your task into stories. Each story gets implemented, verified, and tested in isolation. Failures retry automatically. Nothing ships without a code review. plan → setup → implement → verify → test → PR → review security-audit 7 agents Point it at a repo. Get back a security fix PR with regression tests. Scans for vulnerabilities, ranks by severity, patches each one, re-audits after all fixes are applied. scan → prioritize → setup → fix → verify → test → PR bug-fix 6 agents Paste a bug report. Get back a fix with a regression test. Triager reproduces it, investigator finds root cause, fixer patches, verifier confirms. Zero babysitting. triage → investigate → setup → fix → verify → PR Why It Works Deterministic workflows — Same workflow, same steps, same order. Not "hopefully the agent remembers to test." Agents verify each other — The developer doesn't mark their own homework. A separate verifier checks every story against acceptance criteria. Fresh context, every step — Each agent gets a clean session. No context window bloat. No hallucinated state from 50 messages ago. Retry and escalate — Failed steps retry automatically. If retries exhaust, it escalates to you. Nothing fails silently. How It Works Define — Agents and steps in YAML. Each agent gets a persona, workspace, and strict acceptance criteria. No ambiguity about who does what. Install — One command provisions everything: agent workspaces, cron polling, subagent permissions. No Docker, no queues, no external services. Run — Agents poll for work independently. Claim a step, do the work, pass context to the next agent. SQLite tracks state. Cron keeps it moving. Minimal by design YAML + SQLite + cron. That's it. No Redis, no Kafka, no container orchestrator. Antfarm is a TypeScript CLI with zero external dependencies. It runs wherever OpenClaw runs. Built on the Ralph loop Each agent runs in a fresh session with clean context. Memory persists through git history and progress files — the same autonomous loop pattern from Ralph, scaled to multi-agent workflows. Quick Example $ antfarm workflow install feature-dev ✓ Installed workflow: feature-dev $ antfarm workflow run feature-dev "Add user authentication with OAuth" Run: a1fdf573 Workflow: feature-dev Status: running $ antfarm workflow status "OAuth" Run: a1fdf573 Workflow: feature-dev Steps: [done ] plan (planner) [done ] setup (setup) [running] implement (developer) Stories: 3/7 done [pending] verify (verifier) [pending] test (tester) [pending] pr (developer) [pending] review (reviewer) Build Your Own The bundled workflows are starting points. Define your own agents, steps, retry logic, and verification gates in plain YAML and Markdown. If you can write a prompt, you can build a workflow. id: my-workflow name: My Custom Workflow agents: - id: researcher name: Researcher workspace: files: AGENTS.md: agents/researcher/AGENTS.md steps: - id: research agent: researcher input: | Research {{task}} and report findings. Reply with STATUS: done and FINDINGS: ... expects: "STATUS: done" Full guide: docs/creating-workflows.md Security You're installing agent teams that run code on your machine. We take that seriously. Curated repo only — Antfarm only installs workflows from the official snarktank/antfarm repository. No arbitrary remote sources. Reviewed for prompt injection — Every workflow is reviewed for prompt injection attacks and malicious agent files before merging. Community contributions welcome — Want to add a workflow? Submit a PR. All submissions go through careful security review before they ship. Transparent by default — Every workflow is plain YAML and Markdown. You can read exactly what each agent will do before you install it. Dashboard Monitor runs, track step progress, and view agent output in real time. antfarm dashboard # Start on port 3333 antfarm dashboard stop # Stop antfarm dashboard status # Check status Commands Lifecycle Command Description antfarm install Install all bundled workflows antfarm uninstall [--force] Full teardown (agents, crons, DB) Workflows Command Description antfarm workflow run <id> <task> Start a run antfarm workflow status <query> Check run status antfarm workflow runs List all runs antfarm workflow resume <run-id> Resume a failed run antfarm workflow list List available workflows antfarm workflow install <id> Install a single workflow antfarm workflow uninstall <id> Remove a single workflow Management Command Description antfarm dashboard Start the web dashboard antfarm logs [<lines>] View recent log entries Requirements Node.js >= 22 OpenClaw v2026.2.9+ running on the host Antfarm uses cron jobs for workflow orchestration. Older OpenClaw versions may not expose the cron tool via /tools/invoke. Antfarm will automatically fall back to the openclaw CLI, but keeping OpenClaw up to date is recommended: npm update -g openclaw gh CLI for PR creation steps

██╗ ██╗ █████╗ ██╗ ██╗ ██╗███╗ ██╗████████╗ ██║ ██║██╔══██╗██║ ██║ ██║████╗ ██║╚══██╔══╝ ███████║███████║██║ ██║ ██║██╔██╗ ██║ ██║ ██╔══██║██╔══██║██║ ██║ ██║██║╚██╗██║ ██║ ██║ ██║██║ ██║███████╗███████╗██║██║ ╚████║ ██║ ╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝╚══════╝╚═╝╚═╝ ╚═══╝ ╚═╝ Static analysis for AI-generated code. Catch the security holes Artificial Intelligence leave behind — before they reach production. AI coding assistants (Copilot, Cursor, etc.) are fast, but they consistently introduce the same classes of bugs: hardcoded secrets, SQL injection, missing auth, unsafe eval. hallint catches them. Table of Contents Installation CLI Usage Library Usage Rules Configuration CI Integration Contributing License Installation npm install @asyncinnovator/hallint Or run without installing: npx @asyncinnovator/hallint-cli ./src Requirements: Node.js >= 18 CLI Usage Basic scan npx @asyncinnovator/hallint-cli ./src Scan with glob pattern npx @asyncinnovator/hallint-cli "./src/**/*.ts" Only show high and critical issues npx @asyncinnovator/hallint-cli ./src --min-severity high Run all rules npx @asyncinnovator/hallint-cli ./src --rules all Disable color output (for logs/CI) npx @asyncinnovator/hallint-cli ./src --no-color Options Option Description Default --rules Rule set: recommended or all recommended --min-severity Minimum severity: critical high medium low info info --no-color Disable colored output off --help Show help --version Show version Exit codes Code Meaning 0 No issues found 1 One or more critical or high findings 2 Unexpected error Library Usage Basic scan import { scan } from '@asyncinnovator/hallint' const result = await scan({ files: ['./src/**/*.ts'], }) result.findings.forEach(f => { console.log(`${f.severity} [${f.ruleId}] ${f.filePath}:${f.line}`) console.log(` ${f.message}`) console.log(` fix: ${f.fix}`) }) With options const result = await scan({ files: ['./src/**/*.ts'], rules: 'recommended', minSeverity: 'high', ignore: ['**/node_modules/**', '**/dist/**'], }) Scan a string directly (no file system) import { scanSource } from '@asyncinnovator/hallint' const source = `const apiKey = "sk-abc123def456ghi789jk"` const findings = scanSource(source, 'example.ts') findings.forEach(f => console.log(f.ruleId, f.message)) ScanResult shape { findings: Finding[] // all issues found scannedFiles: string[] // list of files scanned durationMs: number // time taken summary: { // count per severity critical: number high: number medium: number low: number info: number } } Finding shape { ruleId: string // e.g. "hardcoded-secret" severity: string // "critical" | "high" | "medium" | "low" | "info" message: string // human-readable description fix: string // suggested fix filePath: string // absolute path to the file line: number // line number snippet: string // the offending line of code } Rules Rule Severity What it catches hardcoded-secret critical API keys, tokens, passwords in source code sql-injection critical User input interpolated into SQL queries unsafe-eval critical eval() or new Function() with dynamic input missing-auth-check high Route handlers with no auth middleware xss-innerHTML high Unsanitized strings assigned to innerHTML permissive-cors high cors({ origin: '*' }) in route handlers async-no-catch medium async functions with no try/catch or .catch() http-not-https medium Hardcoded http:// URLs in fetch or axios calls Configuration Create a hallint.config.ts at your project root: import type { ScanConfig } from '@asyncinnovator/hallint' export default { rules: 'recommended', minSeverity: 'medium', ignore: [ '**/node_modules/**', '**/dist/**', '**/*.test.ts', ], } satisfies Omit<ScanConfig, 'files'> CI Integration GitHub Actions Add hallint as a PR gate — it exits with code 1 on any critical or high finding: name: hallint on: push: branches: [main] pull_request: branches: [main] jobs: hallint: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-node@v4 with: node-version: 20 - run: npx @asyncinnovator/hallint-cli ./src --min-severity high Pre-commit hook Install husky: npm install --save-dev husky npx husky init echo "npx @asyncinnovator/hallint-cli ./src --min-severity high" > .husky/pre-commit Contributing Contributions are welcome. Each rule is a single file (~30 lines) with a bad.ts / good.ts fixture — a new rule is a good first contribution. Fork the repo Create a branch: git checkout -b feat/rule-your-rule-name Add your rule in packages/core/src/rules/index.ts Add fixtures in packages/core/tests/fixtures/your-rule-name/ Run tests: npm test Open a PR Issues labeled good first issue are pre-scoped and ready to pick up.

ditto.site ditto.site turns a public URL into a self-contained TypeScript app. It captures what the browser actually rendered, then emits a deterministic Next.js App Router project by default, or Vite React when requested. The compiler is not an LLM page author. It is a capture-to-code pipeline: same frozen capture in, byte-stable app out. "Cloning" here means generating a codebase from a live URL — not git clone. You don't need an existing repository, and you don't need the site's source. Point ditto.site at a public URL and it writes you a fresh project from what the page renders in a browser. Read the public development and evaluation method in docs/METHODOLOGY.md. For a map of all the docs, see docs/README.md. Usage REST API: https://api.ditto.site MCP server: https://api.ditto.site/mcp Get a hosted key at https://www.ditto.site/api-key, or call the verified-email signup flow directly: curl -sS -X POST "https://api.ditto.site/v1/signup/request" \ -H "content-type: application/json" \ -d '{"email":"[email protected]"}' The emailed verification link lands on /api-key?token=..., which calls POST /v1/signup/verify and displays the new dtto_live_... key once. Keys are secrets. Put your key in an environment variable (export DITTO_API_KEY=dtto_live_...) and reference $DITTO_API_KEY in every command — never paste the raw key inline, where it lands in shell history, logs, or a chat. Don't commit it. You can rotate a key anytime from the dashboard. REST API Start a clone job: export DITTO_API_URL="https://api.ditto.site" export DITTO_API_KEY="ditto_live_example" curl -sS -X POST "$DITTO_API_URL/v1/clones" \ -H "authorization: Bearer $DITTO_API_KEY" \ -H "content-type: application/json" \ -d '{ "url": "https://example.com/", "options": { "mode": "single", "styling": "tailwind", "framework": "next" } }' The service returns either a queued job or an inline result. A finished result is a file map — every generated file keyed by its app-relative path: { "jobId": "job_123", "status": "succeeded", "files": { "package.json": { "type": "text", "content": "{ ... }", "bytes": 812, "sha256": "..." }, "src/app/page.tsx": { "type": "text", "content": "export default ...", "bytes": 2048, "sha256": "..." }, "public/assets/logo.png": { "type": "binary", "url": ".../files/public/assets/logo.png", "bytes": 5123, "sha256": "..." } } } Turn that JSON into a project on disk with the official unpacker — from a checked-out ditto.site repo with dependencies installed, pipe the response straight in with no temp file: curl -sS -X POST "$DITTO_API_URL/v1/clones" \ -H "authorization: Bearer $DITTO_API_KEY" \ -H "content-type: application/json" \ -d '{"url":"https://example.com/","options":{"mode":"single"}}' \ | npm run --silent unpack -- - ./out npm run unpack -- <clone.json|-> <out-dir> writes the text files inline and materializes binary assets (inline base64, or fetched from their url using $DITTO_API_URL / $DITTO_API_KEY). The CLI package is repo-local until the npm distribution story is ready, so do not use npx ditto yet. See packages/cli for options. If you got back a queued job ({ "jobId": "job_123", "status": "queued" }), poll it, then unpack the finished result — or download the whole app as one archive: JOB_ID="job_123" # poll status, then unpack the finished file map curl -sS -H "authorization: Bearer $DITTO_API_KEY" \ "$DITTO_API_URL/v1/clones/$JOB_ID/result" \ | npm run --silent unpack -- - ./out # ...or grab the whole app as a single archive curl -L -H "authorization: Bearer $DITTO_API_KEY" \ "$DITTO_API_URL/v1/clones/$JOB_ID/bundle?format=tgz" \ -o ditto-clone.tgz Useful options: Option Values Default mode single, multi single styling tailwind, css tailwind framework next, vite next verify true, false false asyncVerify true, false false maxRoutes number service default REST endpoints: Method Path Purpose POST /v1/clones Start a clone GET /v1/clones/:id Read job status and metadata GET /v1/clones/:id/result Read the eager file map GET /v1/clones/:id/files/* Stream one generated file GET /v1/clones/:id/bundle?format=tgz Download the whole app DELETE /v1/clones/:id Delete a clone and its artifacts MCP Connect an MCP client to the hosted Streamable HTTP endpoint: { "mcpServers": { "ditto": { "url": "https://api.ditto.site/mcp", "headers": { "Authorization": "Bearer ${DITTO_API_KEY}" } } } } The MCP server is designed for agents. It returns job ids, metadata, manifests, and file references first, then lets the agent read only the files it needs. Core MCP tools: Tool Purpose clone_website Start a clone and return { jobId, status } get_clone_status Poll job progress get_clone_result Read result metadata without file contents list_clone_files List generated file paths, sizes, and hashes read_clone_files Read selected text files or binary URLs get_clone_bundle Get a download URL for the generated app Example agent prompt: Use the ditto MCP server to clone https://example.com as a Next.js app. Wait for the job to finish, list the generated files, then read package.json, src/app/page.tsx, and src/app/ditto.css. Local CLI # this git clone gets the ditto.site tool itself — the URL you clone into a # codebase comes later, as the argument to `npm run clone`. git clone https://github.com/ion-design/ditto.site.git cd ditto.site npm ci npx playwright install chromium npm run clone -- https://example.com/ --out=./output The generated app lands under output/<site>/app. On success the CLI prints a copy-paste-safe summary — a single quoted cd … && npm install && npm run dev line and pointers to the safe-to-edit files (src/app/content.ts, src/app/components/; the app's AGENTS.md has the full guide). To skip the copy-paste entirely and go straight to a running preview: npm run clone -- https://example.com/ --serve # clone, npm install, npm run dev npm run clone -- https://example.com/ --open # ...and open the browser too Common local variants: npm run clone -- https://example.com/ --mode=multi npm run clone -- https://example.com/ --styling=css npm run clone -- https://example.com/ --framework=vite npm run validate-site -- runs/site-example.com/<timestamp> Without --out, runs land under runs/<site>/<timestamp>/ and a stable runs/<site>/latest symlink always points at the newest clone, so scripts and cd targets don't depend on the timestamp. Local REST And MCP Service Quick inline mode, with no database: npm ci npx playwright install chromium SSRF_ALLOW_LOOPBACK=true npm run dev:api Then call the local REST API: curl -sS -X POST "http://localhost:8787/v1/clones" \ -H "content-type: application/json" \ -d '{"url":"https://example.com/","options":{"mode":"single"}}' For the queued service with Postgres and MinIO: docker compose up -d cp .env.example .env DATABASE_URL=postgresql://postgres:postgres@localhost:5432/ditto_site \ npm run db:migrate npm run dev:api npm run dev:worker The local MCP endpoint is http://localhost:8787/mcp. What You Get A generated app includes: a runnable Next.js or Vite React project, reconstructed pages and route modules, captured assets, fonts, icons, manifest files, and metadata, robots, sitemap, llms.txt, and JSON-LD when discoverable, small ditto runtime helpers for recognized interactions and motion, generated AGENTS.md and ARCHITECTURE.md handoff docs. Delivery output is under generated/app/ during validation and under <out>/<site>/app for CLI delivery. How It Works URL -> browser capture -> normalized render IR -> deterministic inference -> app generation -> asset materialization -> optional validation Capture records DOM, computed styles, layout boxes, source metadata, CSS, fonts, assets, screenshots, interaction states, and reproducible motion where it can be observed safely. Unsupported app logic, auth, payments, personalization, and arbitrary third-party JavaScript are not replayed. For the detailed service API, see docs/SERVICE.md. For deployment, see docs/DEPLOY.md. For the development method behind the compiler, see docs/METHODOLOGY.md. Hosted deployments should keep /v1/clones* and /mcp behind API-key auth. When SIGNUP_ENABLED=true in DB mode, the Resend-backed POST /v1/signup/request and POST /v1/signup/verify flow can publicly mint dtto_live_... keys from verified email links while storing only key hashes. Keep SIGNUP_DIRECT_ENABLED=false in production unless direct unauthenticated minting is intentional. Repository Map Path Purpose compiler/ deterministic capture, inference, generation, and validation packages/core/ compiler adapter and file-map helpers packages/cli/ ditto CLI — unpack a clone result JSON into a project tree packages/api/ Hono REST API and MCP server packages/db/ Drizzle schema, migrations, repository, and queue wrapper packages/storage/ local and S3/R2 artifact storage packages/worker/ queued clone runner and optional verification docs/ methodology, service, deployment, release, and responsible-use docs examples/ benchmark results and visual evidence Responsible Use Use ditto.site only where you have the right to inspect, copy, transform, and operate on the target content. Do not use it for phishing, impersonation, credential capture, bypassing access controls, or high-volume third-party capture without permission. See docs/RESPONSIBLE_USE.md. Contributing npm ci npx playwright install chromium npm run typecheck npm test Browser tests require Chromium. Postgres-backed tests use TEST_DATABASE_URL or the local compose stack. Changes that alter compiler output should include a focused fixture or benchmark note. The repository is MIT-licensed open source. The npm workspaces are intentionally marked private until the package boundaries are ready for public npm publishing. See CONTRIBUTING.md, SECURITY.md, SUPPORT.md, and CODE_OF_CONDUCT.md.

One file across every agent. Write yourself down once. Every AI you use reads it before answering, and proposes updates as it learns you. You approve the good ones. Home · Docs · Pricing · Stack · Privacy What is Creed? Anyone using AI seriously pays the same tax: re-explaining themselves every chat, every tool, every session. Creed (creed.md) kills that tax with one file. Your Creed is a curated personal context profile in plain Markdown, sized to read in under a minute. Connected agents (Claude, ChatGPT, Codex, Cursor, Devin, and any MCP client) read it before they answer you, and propose edits as they learn new things. The file sharpens over time instead of rotting in your notes. It is not a notes app, a journal, or a memory dump. If you already maintain a hand-rolled CLAUDE.md or a "things ChatGPT gets wrong about me" list, Creed is that file as a real product: first draft written for you, quality scored, one canonical version everywhere, agent edits gated behind your approval. ┌──────────────────────┐ ┌────────────────────┐ │ You (onboarding) │ ──────► │ Your Creed file │ │ (one short pass) │ │ 10 sections, MD │ └──────────────────────┘ └─────────┬──────────┘ │ ┌────────────┴────────────┐ ▼ ▼ ┌─────────────────────┐ ┌──────────────────────┐ │ Agent reads it │ │ Agent proposes an │ │ before answering │ │ update; you approve │ └─────────────────────┘ └──────────────────────┘ Ten sections, five always-on (Identity, Goals, Work, Preferences, Routines) and five optional (Beliefs, Constraints, People, Health, Context). Every section is agent-writable, per-section permissions decide whether edits apply directly or wait for review. Personal is the core one-user product. Company extends the same file model into a shared workspace: roles, per-section permissions, attribution, invites, pooled AI credits, seat billing. Quickstart Prerequisites: Node 20+ and a free Supabase project. (OpenRouter key only for AI features, Stripe only for paid-plan flows.) git clone https://github.com/connorhpbrn/creed.git cd creed && npm install cp .env.example .env.local # fill in the five required vars below supabase link --project-ref <your-project-ref> && supabase db push npm run dev # → http://localhost:3000 Minimum .env.local to boot: NEXT_PUBLIC_SITE_URL=http://localhost:3000 NEXT_PUBLIC_SUPABASE_URL=https://<project>.supabase.co NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY=<publishable-key> SUPABASE_SECRET_KEY=<service-role-key> CREED_ENCRYPTION_SECRET=$(openssl rand -base64 32) Every other variable (OpenRouter, Stripe, GitHub sync, branding, feedback) is documented inline in .env.example. supabase db push creates the full schema: sections, proposals, activity, tokens, MCP, GitHub, AI usage, audit log, rate limits, entitlements, all behind row-level security. Wire up Stripe for the paid flows (optional) The hosted app gates /file behind a paid entitlement. Locally you can skip Stripe entirely (unentitled users land on /pricing), or run the full flow: set the four STRIPE_* vars from .env.example with sandbox keys, then stripe listen --forward-to localhost:3000/api/stripe/webhook and copy the printed whsec_… into STRIPE_WEBHOOK_SECRET. Test payments then auto-grant entitlements. Deploy your own hosted instance Set NEXT_PUBLIC_SITE_URL to your deployed origin so OAuth and Stripe redirects resolve. Set CREED_CSP_ENFORCE=1 after watching one deploy cycle in Report-Only mode. Create a live Stripe webhook endpoint at https://<your-domain>/api/stripe/webhook and use its signing secret. Example agent prompts referencing https://creed.md are illustrative; real URLs derive from your NEXT_PUBLIC_SITE_URL. Connect an agent Open /connections and add the Creed MCP URL to your agent as a custom connector. The client opens a browser, you click Allow, done. No tokens to copy. Creed is its own OAuth 2.1 authorization server (/authorize, /token, /register, /.well-known/*), so any spec-compliant MCP client connects from the server URL alone. First-class connect flows exist for Claude Code (one-line claude mcp add), Codex, Cursor (one-click), ChatGPT, Devin, OpenClaw, Hermes, OpenCode, Factory, Manus, and custom agents. Clients that do not speak MCP can use the documented /api/creed HTTP API. Creed also ships a first-party terminal client. It uses the same OAuth screen and discovers every tool, resource, and prompt from the live MCP server, so a new MCP tool appears in the CLI without a second implementation or release. npx creed-cli Agents get three verbs: read the file, propose an update, or direct-edit where you have granted it. The MCP health dashboard tracks per-agent reads, edits, proposals, and outcomes while keeping CLI activity separate. Stack Layer Choice Framework Next.js 16 (App Router, Turbopack), React 19, TypeScript UI Tailwind CSS v4, shadcn/ui, Tiptap editor, Framer Motion Backend Supabase (auth, Postgres, RLS, realtime), pg_cron retention jobs AI OpenRouter (managed credits or BYOK), per-feature model routing Billing Stripe (Personal and Company plans, seats, webhooks) Sync GitHub push/pull of creed.md, lossless Markdown round-trip Full tour at creed.md/stack. Repository map app/ ├── (creed-app)/ signed-in product (/file, /connections, /settings) ├── api/ session-authed + token-authed APIs (incl. /api/creed, MCP, OAuth) ├── home/, onboarding/ public landing and first-run flow components/ ├── creed/ product UI marketing/ public site ├── auth/ sign-in ui/ shadcn primitives lib/ ├── creed-data.ts types, sections, agent contract ├── creed-backend.ts Supabase reads/writes ├── creed-markdown.ts push/pull Markdown parser (lossless round-trip) ├── ai/ OpenRouter client, model catalog, quality scoring ├── company-*.ts Company roles, seats, billing, invites supabase/migrations/ canonical schema (RLS everywhere) tests/ node:test suites Commands npm run dev # dev server (Turbopack) npm test # test suite (node:test) npx tsc --noEmit # typecheck npm run lint # ESLint npm run build # production build Contributing PRs welcome. Read CONTRIBUTING.md first; it is short and saves us both time. AI agents: read AGENTS.md instead, it is the same information written for you. Found a vulnerability? Do not open a public issue; see SECURITY.md.

From pixel to source file in one keystroke. You are a VibeCoder? Ever tried to describe a UI element with human language then see your agent burn your quota just to figure out what on Earth you are talking about, then fix the wrong thing? You are a Senior who knows what Ctrl + Shift + I is to copy the right thing and give it to your Agent, but you feel pathetic spending your life doing that? I cured the curse. Hover on what you want the AI to change, press Alt + C, then Ctrl + V. Features Dual Interaction Modes: Inspector Mode: Hover over components to view layout boundaries, selector paths, and file deep-links. Copies HoverSource Component Metadata with Alt + C. Design Mode (Alt + X to toggle): Drag a targeting crosshair to snap against horizontal/vertical edges and measure pixel-perfect offsets. Copies HoverSource Design Placement Metadata with Alt + C. Copy AI-Ready Metadata (Alt + C / Alt + Shift + C): Copies a structured Markdown block to your clipboard — component name, exact file path with line/column, computed styles, parent visual effects with CSS source locations, layout constraints, JSDoc comments, and raw JSX attributes (or snapping offsets and absolute CSS anchors in Design Mode). Pressing Alt + Shift + C copies the metadata of all ancestor layers under the cursor plus a minified structural HTML skeleton of the target element, providing the AI with layout and nesting context. Freeze State (Alt + P): Locks dynamic elements (like tooltips, popovers, or dropdowns) in place so you can hover and capture them without them disappearing. Toggle Overlay (Alt + H): Show or hide the developer overlay bounding box and floating spec card. Deep-linking (Click filename): Instantly opens the file in your preferred editor (VS Code or Cursor) at the exact line number. Source Line Correction: Silently checks and corrects compiler-shifted line numbers in the background. Layered Element Navigation (Alt + Shift + Scroll): Cycle through overlapping DOM elements under the cursor using a scroll combination, showing a clean 2D overlapping layer stack in the tooltip to easily target parent/child elements. Customize shortcuts in the dashboard. Element Selector & CSS Source Location: Captures the exact HTML tag and classes of the hovered element, along with the specific line and file of their CSS definition. This includes support for CSS Preprocessors (Sass, SCSS, Less) with nested selectors, and CSS Modules (auto-resolving hashed class names back to their source definitions). Benchmark: Human Language vs. HoverSource Metadata To measure the efficiency gains, we ran comprehensive benchmarks with an AI coding agent (Gemini 3.5 Flash) performing style modification tasks in a dry-run environment (logged using chronicle-mcp). We compared three prompt variations: Prompt A: Pure Natural Language (simulating a user who does not know the codebase). Prompt B: File Path Only Context (manual file path and component naming). Prompt C: HoverSource Metadata (automatic clipboard metadata block). The benchmarks were performed on two public open-source projects of different scales: Cal.com (cal.diy): Giant enterprise-level monorepo (~7,700 source files, multiple apps/packages). YumeShelf: Medium-sized desktop Electron application (~200 source files). Benchmark 1: Cal.com Monorepo (Giant Enterprise Codebase - 10 Tasks) Detailed Report & Logs: Cal.com Benchmark Report Metric Pure Natural Language (A) File Path Only (B) HoverSource Metadata (C) Delta (C vs A) Task Achievement 60.0% (6/10) 100.0% (10/10) 100.0% (10/10) +66.7% Avg Agent Steps 65.6 18.0 17.1 -73.9% Avg Tool Calls 30.5 6.5 5.9 -80.7% Avg Execution Time 142.0s 44.2s 16.4s -88.5% (8.7x faster) Avg Cumulative Input Tokens 651,681 37,858 35,733 -94.5% (18.2x fewer tokens) Avg Peak Context Window 28,257 7,372 6,486 -77.0% Benchmark 2: YumeShelf (Medium Codebase - 5 Tasks) Detailed Report & Logs: YumeShelf Benchmark Report Metric Pure Natural Language (A) File Path Only (B) HoverSource Metadata (C) Delta (C vs A) Task Achievement 100.0% (5/5) 100.0% (5/5) 100.0% (5/5) - Avg Agent Steps 34.4 22.0 26.0 -24.4% Avg Tool Calls 15.2 8.8 11.0 -27.6% Avg Execution Time 34.4s 38.8s 24.8s -27.9% (1.4x faster) Avg Cumulative Input Tokens 118,354 44,382 61,255 -48.2% (1.9x fewer tokens) Avg Peak Context Window 14,140 8,589 9,984 -29.4% Why HoverSource scales with codebase complexity Monorepo Efficiency Takeaway: In a 7,700-file monorepo like Cal.com, simply providing the correct file path in the prompt (File Path Only) saves 68.9% of execution time and 94.2% of tokens your agent needs to digest. HoverSource provides all necessary DOM, CSS, and component metadata to push efficiency even further to -88.5% execution time and -94.5% input tokens — basically skipping the entire code-digging session and jumping straight to reasoning and execution. These savings scale linearly with codebase size. Zero Search & Exploration Overhead: In YumeShelf, the natural language agent had to scan directories and run global searches (grep) to locate the card and CSS files. In Cal.com's monorepo, this overhead exploded. The agent had to list multiple directories, inspect packages, and evaluate ambiguous components across different packages (such as packages/ui vs packages/coss-ui) just to find the active Button code. Guided by HoverSource, the agent went straight to the exact target line in a single turn. Context Preservation: By bypassing global searches and file listings, HoverSource keeps the agent's context window extremely clean, leading to a 98.6% reduction in token consumption on Cal.com (from half a million tokens to just under 7k). This directly translates to lower API costs and faster responses. Modes of Operation HoverSource runs in two distinct interaction modes depending on your task. You can toggle between them at any time by pressing Alt + X. 1. Inspector Mode (Default) Ideal for debugging, modifying, or refactoring existing elements. Hovering elements highlights their layout bounding box and opens a floating card containing file paths, component names, CSS locations, and layout context. Pressing Alt + C copies Component Metadata (see Clipboard Output). 2. Design Mode Ideal for positioning new UI elements (cards, badges, modals, tooltips) relative to existing elements. Activates a drag-and-drop targeting crosshair. Snaps the crosshair horizontally or vertically against nearby element boundaries (edges or center axes) to measure precise offsets (dX, dY). Pressing Alt + C copies Design Placement Metadata containing: Exact target and snap anchor selectors. Pixel-perfect offsets and boundaries. Pre-computed absolute position CSS block (top, left, white-space). Structural guidance for AI agents to decide on DOM insertion and flex/grid adjustments. Framework Support Matrix HoverSource supports resolving metadata for multiple frontend frameworks at different levels of depth depending on what information is exposed by the framework's development mode: Metadata Field React (Non-Invasive / Invasive) Vue (Non-Invasive / Invasive) Svelte (Non-Invasive) Angular (Non-Invasive / Invasive) SolidJS (Non-Invasive) Preact (Non-Invasive) Astro (Non-Invasive) Vanilla / Fallback Component Name Resolved Resolved Resolved Resolved Resolved Resolved Resolved Fallback (DOM tag) File Path Resolved Resolved Resolved Unresolved / Resolved* Resolved Resolved Resolved Partially Resolved** Line Number Resolved None / Resolved* Resolved None / Resolved* Resolved Resolved Resolved Resolved** Column Number Resolved None / Resolved* Resolved None / Resolved* Resolved Resolved Resolved Resolved** Tag Name & Classes Resolved Resolved Resolved Resolved Resolved Resolved Resolved Resolved * Note: Vue and Angular require compile-time template tagging (Invasive mode via hs install --vue or hs install --angular) to expose line/column locations (and file path for Angular). Other frameworks resolve them out-of-the-box in development mode (Non-Invasive). For server-side environments (React Server Components / SSR in Next.js), React utilizes automatic, zero-config on-disk runtime patching during dev server execution. ** Note: Vanilla JS/TS resolves source locations dynamically via runtime monkey patching of DOM creation APIs (document.createElement and Element.prototype.innerHTML setter). Static elements in index.html or elements created before the overlay is injected will remain unresolved (Unknown). Next.js & React Server Components (RSC) Support For Next.js 14+ projects, HoverSource automatically resolves source code locations (file path, line, and column) for both server-rendered components (SSR) and React Server Components (RSC) when launched using hs dev or hs start. Mechanism: HoverSource temporarily patches the standard React CJS development runtimes and Next.js's vendored app-page router runtimes on disk during development server execution. All patched files are restored to their original state upon process exit or CLI shutdown. Optimized SWC Integration: For elements compiled with dev-mode source tracking (__source), HoverSource reads the source locations directly without performance overhead. For RSC elements where compiler-level source attributes are stripped, HoverSource resolves locations dynamically on the server. Vanilla JS/TS Source Resolution For projects not using a component framework, HoverSource resolves source locations dynamically using a runtime monkey-patching approach: Overrides document.createElement to capture the stack trace when an element is instantiated. Overrides the Element.prototype.innerHTML setter to capture the stack trace and tag the element and its direct children. Parses the V8 stack trace to extract the file path, line, and column, and stores them in the data-hs-source attribute. Limitations of Vanilla Resolution Timing & CDP Injection Delay: Only elements created or modified after the HoverSource overlay is loaded and the monkey patches are applied will have source metadata. In Electron or SPA applications, elements in the initial HTML payload or rendered immediately during application boot time will be painted before the CDP injector connects. These elements will initially show Unknown. Workaround A (Interactive): Simply perform any UI action that triggers a re-render or re-creates the DOM elements (e.g., toggling a favorite state, applying a search query, switching tabs, or clicking a refresh list button) once the HoverSource overlay is loaded. Workaround B (Pre-Injection): For 100% accurate startup resolution without manual interaction, manually add the HoverSource overlay script tag at the very top of your project's main HTML file's <head> during active development: <script src="http://127.0.0.1:7300/hoversource-overlay.js"></script> Bundling/Transpilation: If the code is bundled or transpiled without source maps, the captured stack trace will point to the bundled output rather than the original source files. Proxy & Security Transport Matrix When utilizing HoverSource in Web Application Proxy Mode (hs --target=<url>), the reverse proxy employs dedicated routing and headers interception layers to handle modern browser restrictions:

Seaworthy Insurance MCP Server A live Model Context Protocol server that lets AI agents take action on behalf of their users with Seaworthy Insurance, an independent brokerage specializing in individual disability insurance for high-income professionals (physicians, dentists, CRNAs, attorneys, executives). To our knowledge, this is the first disability insurance brokerage to expose an agent-callable quote action over MCP. Endpoint https://mcp.seaworthy.io/mcp Transport: Streamable HTTP Auth: none (open). The write action is protected server-side by input validation, per-IP rate limiting, and duplicate suppression rather than client authentication. Server card: https://seaworthy.io/.well-known/mcp/server-card.json Registry: io.seaworthy/mcp in the official MCP Registry Tools Tool Type What it does quote_request action Submits a disability insurance quote-comparison request to the Seaworthy sales pipeline on the user's behalf. A licensed broker follows up within one business day. get_specialty_guide read Coverage guidance for a specific profession or medical specialty. compare_carriers read Structured comparison of the five major individual disability carriers. estimate_benefit_cap_gap read Income-replacement gap math between a group LTD cap and a target. list_riders read Definitions and trade-offs for the major disability insurance riders. get_education_article read Retrieves a named education article as structured metadata plus a link. quote_request inputs Required: first_name, last_name, email, phone, profession, state, dob, gender, annual_income. Optional: life_insurance_interest, notes, referral_source. The agent must confirm the user has consented to be contacted before calling it. SSN, medical history, and banking details are never collected through this tool. Security & privacy This is a remote, stateless server. Connecting a client runs no code on the user's machine and gives the server no access to the local filesystem. Read tools return only public, vendor-verified facts. The one write tool (quote_request) is guarded server-side by input validation, per-IP rate limiting, and duplicate suppression, not by client credentials. That is why the endpoint can be open without exposing the pipeline to abuse. No sensitive data (SSN, medical, banking) is ever accepted, and the agent must confirm consent before submitting. Minimal data flow: submissions go to Seaworthy's CRM (Salesforce Web-to-Lead) and nowhere else. The server keeps no conversation or query history, and no secrets live in this repository. Full details and a private disclosure channel are in SECURITY.md. Try it Add https://mcp.seaworthy.io/mcp as an MCP server in any MCP-capable client (Cloudflare AI Playground, Claude Desktop, MCP Inspector, or a custom connector), then ask it to get a disability insurance quote. Stack Cloudflare Worker (TypeScript), stateless JSON-RPC over Streamable HTTP. Quote submissions write to Salesforce Web-to-Lead. No secrets live in this repository. Author Built by Toby Lason, Managing Partner, Seaworthy Insurance.

LanceDB Explorer Browse LanceDB databases and tables directly inside VS Code. Features Open any local LanceDB database from the sidebar and browse its tables in a tree view. View table data in a paginated, resizable grid (powered by Tabulator). Column type hints, row numbers, hover tooltips for full cell content, and one-click copy to clipboard. Edit cell values — click the pencil icon to edit in a modal, including JSON editing for list/vector columns. Values are validated against the column's type before saving. Clear a cell to null with one click, on any nullable column. Delete a row via the row-number column, with a Cancel/Delete confirmation prompt since it can't be undone. Pin rows to keep them visible above the current page regardless of sorting, filtering, or pagination. Sort by column — pushes a real ORDER BY to LanceDB (not just a local re-sort of the current page), so it's consistent across pagination. Filter by column — case-insensitive text/number/boolean matching, pushed to LanceDB as a WHERE clause; matches update the row count and pagination too. Pin columns to keep them visible while scrolling horizontally; multiple pinned columns stack side by side at the left edge. Matches your VS Code theme automatically (light, dark, and high-contrast). Usage Open the Command Palette and run LanceDB: Open Database..., then select a LanceDB database directory. Expand the database in the LanceDB view (Activity Bar) → Tables to see the tables it contains. Click a table to open it in a data grid. Use the toolbar at the bottom to page through rows. Hover a cell for copy/edit/clear actions, or hover a row number for pin/delete. Hover a column header for sort, filter, and pin controls. Development npm install npm run watch # rebuild the extension and webview bundles on change Press F5 in VS Code to launch an Extension Development Host with the extension loaded. Other scripts: npm run typecheck # type-check the extension host and webview code npm run build # production build npm run package # package a .vsix with vsce Requirements Node.js >= 18 (required by the LanceDB native bindings)

typescript

Explore categories

How Product Visit works