Projects on Min Liu

Chamfer

Mon, 01 Jan 0001 00:00:00 +0000

The problem

Text-to-CAD demos often stop at visual plausibility. A model can produce convincing code, declare success, and still deliver the wrong dimensions, missing features, or invalid geometry. That gap matters when the output is supposed to become a physical object.

Chamfer treats verification as part of generation, not a final cosmetic check. The agent converts a request into a persistent plan, writes build123d CAD code or drives Autodesk Fusion, executes the work against a real geometry engine, and reconciles measured evidence with every active requirement before delivery.

Engineering the agent loop

The harness gives the model a focused tool surface instead of a general coding environment. Complex tasks begin with an evidence-backed plan. Focused documentation retrieval and progressive CAD skills provide domain knowledge only when the task needs it, while long-session compaction preserves requirements, the plan, and verification state.

For image-driven work, Chamfer maintains explicit reference coverage. A build cannot pass the final gate until the latest inspection views have been compared with every active reference. Deterministic checks handle facts the geometry kernel can prove—body count, dimensions, holes, and feature presence—while visual inspection handles intent that is genuinely visual.

Measured, not asserted

Agent changes are gated by an evaluation corpus and a geometry-kernel oracle. The comparison harness runs the same parts through different agents and records correctness, tool calls, context, output, cost, and wall time. This makes prompt or tool changes an engineering decision with a baseline, not a matter of taste.

The product remains local-first when run through npx chamfer: conversations, CAD execution, and geometry stay on the user’s machine, while the user chooses the model provider. Finished work can be inspected interactively and exported for downstream CAD or fabrication workflows.

Actual Voice

Mon, 01 Jan 0001 00:00:00 +0000

From audio to an actionable signal

Spoken feedback contains nuance that surveys often erase, but listening to every response does not scale. Actual Voice turns those responses into patterns leaders can use: recurring themes, engagement signals, and dashboard-ready summaries.

The hard part is not sending audio to a transcription model. It is moving sensitive data through storage, transcription, per-response analysis, aggregation, and regeneration while keeping each stage observable and recoverable.

A durable asynchronous workflow

Uploads enter a tenant-aware pipeline backed by Supabase Storage, Postgres, Edge Functions, and worker queues. Each stage records enough state to retry safely. Debounced aggregation prevents every new response from triggering redundant group computation, while fallback handling keeps temporary queue or model failures from blocking the respondent experience.

The analysis contract separates respondent-level evidence from group-level interpretation. Relevance filtering happens close to the source analysis so weak or off-question themes do not become authoritative simply because they survived into the final prompt.

Trustworthy summaries

Aggregate outputs enforce product contracts at runtime—privacy boundaries, required structure, and useful length—without reducing the model to rigid template filling. Production validation force-regenerates current insight data rather than accidentally reviewing stale cached summaries.

The result is an AI feature that behaves like production infrastructure: it can be monitored, repaired, backfilled, and evaluated against real questions and transcripts.

OncoMate

Mon, 01 Jan 0001 00:00:00 +0000

Operational knowledge is fragmented

Equipment teams troubleshoot across manuals, fault-code tables, preventive-maintenance records, inventory, and the memory of experienced technicians. A generic chatbot can sound helpful while missing the exact machine, prior repair, or part constraint that changes the next action.

OncoMate begins with the asset and its evidence. A technician describes the problem in ordinary language; the agent identifies the equipment, retrieves relevant fault references and completed repairs, checks PM context and parts availability, then proposes a reviewable sequence of next checks.

A knowledge engine, not a chat wrapper

The ingestion layer parses PMI machine files such as XML and WOX into structured fault events, flow states, and board-temperature histories. Work orders, maintenance outcomes, and service notes flow back into the same retrieval layer when work closes.

The agent uses a multi-turn tool loop rather than one large RAG prompt. Each step can narrow the asset, query a different evidence source, or surface a constraint. The answer remains tied to records the user can inspect instead of hiding behind model confidence.

Designed for an accountable domain

Authenticated access and tenant boundaries protect operational records. Retrieval failures degrade explicitly instead of inviting unsupported generation. The system treats the proposed work plan as decision support: useful because its evidence is visible, and reviewable because the technician remains in control.

ACAV

Mon, 01 Jan 0001 00:00:00 +0000

Compiler facts are hard to navigate

Clang exposes a rich semantic model of C++, but the default inspection experience is usually a huge textual AST dump. It is difficult to connect a node back to the precise source range, compare related declarations, or explain what the compiler sees to another person.

ACAV turns that raw structure into a native visual workspace. The tree, source panes, node properties, comments, and diagnostics remain connected, so exploration does not discard the evidence that makes the compiler output useful.

Working with large trees

Materializing an entire AST into QML components would make realistic translation units slow and memory-heavy. ACAV indexes the underlying compiler data and creates visible UI nodes lazily, keeping interaction responsive while preserving access to the full structure.

Source-location handling normalizes the awkward realities of compiler APIs: spelling and expansion locations, ranges, generated nodes, and metadata whose lifetime is tied to the AST context. The implementation keeps ownership and extraction explicit at the C++ boundary rather than leaking fragile compiler objects into the UI.

Why it matters

The tool supports research and static-analysis development, but it is equally valuable as an explanation surface. Engineers and students can point to an exact compiler node, see the code that produced it, and inspect its properties without learning to decode a wall of dump output first.

jqcpp

Mon, 01 Jan 0001 00:00:00 +0000

A small tool with visible engineering

JSON is easy for software to exchange but awkward for a person to inspect quickly. Pulling one nested field or array slice often becomes a temporary script, manual copying, or a long scroll through an API response.

jqcpp focuses on the common terminal workflow: identity filters, nested field and array access, slicing, iteration, simple arithmetic, length, and keys. It does not attempt to clone the complete jq language; the smaller scope keeps the implementation understandable.

A compiler pipeline in miniature

The tool is divided into explicit stages. A JSON tokenizer and parser build the value tree. A separate expression lexer and parser produce a filter AST. The evaluator applies that AST to the input, and the pretty printer serializes the result.

Objects use vector-backed key-value storage so insertion order stays stable in formatted output. The value type is move-oriented with explicit deep-copy behavior where evaluation needs an independent result from nested data.

Quality at the boundaries

Catch2 tests cover the layers independently and exercise the complete command-line path. That separation matters because a tokenization defect can otherwise masquerade as a parser or evaluation bug. GitHub Actions configures, builds, and runs the suite so the repository behaves like a maintained open-source tool rather than a one-off parser exercise.