VicroCode
Make Code Create Value
VicroCode is a lightweight online platform for publishing, running, sharing, and monetizing code projects. Launch HTML, Python, SQLite, AI agents, management tools, games, and more without server setup.
Please wait while VicroCode loads. You can also explore the AI programming guide
Loading...

AI MARKET GUIDE

Make Your Agent Cite Its Findings, Not Guess Them

The reusable half of that app-evidence MCP tool is the citeable index, not the unpacker. Here is how to rebuild the search-and-cite split on VicroCode.

The most reusable idea in that app-evidence MCP tool isn't the part that pries open a signed app. It's that every finding it hands back carries a stable citation ID: a `file:line:column` plus an evidence hash like `ev_8392e3ae42a5dfcc`. The agent returns something you can click back to, not a confident paragraph it invented.

I want to pull that split apart, because only one half of it needs a reverse-engineering toolchain. The other half is a plain data problem you can build on VicroCode today, and it's the half that actually changes how the agent behaves.

What is the durable half of the tool?

The durable half is the citeable index, not the unpacker. When the author ran the tool against one app (车工计算器), the report didn't dump a flat list. It reported 195 routes grouped into 22 path groups, the largest holding 74, flagged the stack as uni-app / HBuilder, and indexed 1485 native procedures and 6203 strings. Every one of those items is addressable by an evidence ID plus its exact location, so each conclusion in the report points back to a line.

The design choice underneath it: the agent's context holds only summaries, while the full semantic graph stays local. That's what keeps a large artifact from flooding the model's window, and it's the part that survives even if the unpacking front end changes.

Why do agents guess without citation IDs?

Because a blob of JSON pasted into a chat window has no address the agent can point at. The problem the author described was an afternoon of unpacking, grepping, and pasting fragments into a dialog box to answer one question about a competitor. Once each finding has a stable ID and a `file:line`, the question collapses into a lookup: `search_findings(query="hong", types=[route])` returned 17 findings spread across 2 files, each listed with its line.

The index also has to tell absence apart from ignorance. The author hit this directly: the report took only the most recent 20 tasks, cut off the 25th (a native check), and then wrote "encryption status unknown" for a package that was in fact encrypted (`cryptid=1`). He fixed it and added tests. The lesson is that "not checked" and "not found" are different states, and an evidence index that blurs them will make the agent sound sure about things it never verified.

How do you rebuild the split on VicroCode?

Build three pieces that mirror the original, mapped to confirmed capabilities. The extraction engine runs as Python: you run Python online to parse artifacts you can legitimately read (text configs, JSON bundles, your own source, logs) into findings, each one a record with a type, a location, and a content hash.

The index needs two shapes of lookup. Use a SQLite database for exact queries by name, type, and location, and store the evidence hash as the primary key so a citation stays stable across re-runs. For "find strings that mean roughly this," add a LanceDB knowledge base over the string and description text, which is what makes fuzzy search over 6203-string-scale corpora usable.

The third piece is the tool the agent calls. Expose a single `search_findings` endpoint through API Endpoint Hosting and in-platform tool calls, then use AI agent development to wire the agent so it chooses when to call that endpoint and returns short summaries with their IDs. The full index never enters context; only the matched findings do.

Where does VicroCode stop short of the unpacker?

VicroCode cannot rebuild the binary-cracking front end, and that is a hard boundary. The original install pulls roughly 1GB of JDK, Ghidra, and ipatool, decrypts Mach-O and PE binaries, and downloads through your own Apple ID. None of that maps to the confirmed VicroCode capabilities, which cover Python execution, hosting, databases, model APIs, and tool calls, not binary decompilation or app-store downloads.

So draw the line the same way the author did between engine and index. Do any legitimate unpacking off-platform on artifacts you're authorized to read, then feed the extracted text and structure into VicroCode, which owns the index and the query tool. That keeps the risky, environment-specific work outside and the durable, reusable work inside.

What does the search tool actually return?

It returns a short list of findings with their IDs, never the whole index. That's the behavior worth copying: the agent gets 17 findings and their locations, decides what to ask next, and every answer it gives traces back to a line you can open.

One honest caveat on the source. The reference tool is version 0.2.7, labeled preview, with 0 stars and no real user feedback yet, so any claim about its accuracy or speed is unverified. Treat the citation-ID pattern as the thing to adopt, build it on your own data, and verify the findings before you trust them.

FAQ

Can VicroCode decrypt or decompile an app binary?

No. Binary decryption and decompilation (the Ghidra, ipatool, Mach-O/PE work in the reference tool) fall outside the confirmed capabilities; VicroCode handles the Python extraction, the index, and the agent-facing search tool, not the unpacking.

Why store an evidence hash as the key?

So a citation stays valid across re-runs. If the ID is derived from the finding's content rather than its position in the latest output, the agent can reference `ev_8392e3ae42a5dfcc` and still resolve to the same evidence after you re-index.

Should the index use SQLite or LanceDB?

Both, for different queries. Use SQLite for exact lookups by name, type, and location, and a LanceDB knowledge base for semantic search over strings and descriptions where an exact match won't find what you mean.

Further reading

The agent-calls-a-tool pattern is specified in the Model Context Protocol, the exact-string index maps to SQLite FTS5, and the semantic layer is documented at LanceDB.