AutomaDocs
Connects to your GitHub repos, parses the code with Tree-sitter, and generates docs that refresh on every push. A chat answers questions about the code with citations to files and lines. Free, Pro ($49/mo) and Team ($149/mo) plans through Stripe.
- Role
- Creator
- Years
- 2024-2026
- Status
- Live
Numbers
- Pro plan
- $49/mo
- Team plan
- $149/mo
See it work
Real output, captured from the product. Open Inspect to see how it got there.
AutomaDocs
Docs that rebuild on push
/// Commits the transaction, by removing it from the active set. This will
/// immediately make its writes visible to subsequent transactions. Also
/// removes its TxnWrite records, which are no longer needed.
///
/// NB: commit does not flush writes to durable storage, since we rely on
/// the Raft log for persistence.
pub fn commit(self) -> Result<()> {
if self.state.read_only {
return Ok(());
}
let mut engine = self.engine.lock()?;
let remove: Vec<_> = engine
.scan_prefix(&KeyPrefix::TxnWrite(self.state.version).encode())
.map_ok(|(k, _)| k)
.try_collect()?;
for key in remove {
engine.delete(&key)?
}
engine.delete(&Key::TxnActive(self.state.version).encode())
}commit Function Documentation
Description
The commit function is responsible for finalizing a transaction by removing it from the active set. This action makes the transaction's writes visible to subsequent transactions. Additionally, it cleans up any associated TxnWrite records that are no longer necessary. It is important to note that this function does not flush writes to durable storage, as persistence is managed through the Raft log.
Parameters
self: The instance of the transaction being committed. It is consumed by the function.
Returns
Result<()>: Returns anOk(())if the transaction is successfully committed. If an error occurs during the process, it returns anErrvariant containing the error details.
Throws
- This function may throw errors related to:
- Lock acquisition on the engine (
self.engine.lock()?). - Errors during the scanning of transaction write keys (
engine.scan_prefix(...)). - Errors during the deletion of keys from the engine (
engine.delete(...)).
Example
fn main() -> Result<()> {
let transaction = Transaction::new(); // Assume Transaction is defined elsewhere
// Perform operations on the transaction
transaction.commit()?;
Ok(())
}Notes
- The function checks if the transaction is in a read-only state (
self.state.read_only). If it is, the function will return early without making any changes. - The function utilizes a lock on the engine to ensure thread safety while accessing and modifying the state.
- The cleanup process involves scanning for all keys associated with the transaction's writes and deleting them, followed by the removal of the transaction from the active set.
- Ensure that the transaction is not in a read-only state before calling this function to avoid unnecessary operations.
The brief
Docs go stale as soon as the code changes.
The build
Claude writes the docs, Tree-sitter parses the code, and Pinecone retrieval backs the chat. A GitHub webhook regenerates docs on push. There is also an MCP server, a CLI and a GitHub Action.
What shipped
Live at automadocs.com with Stripe checkout.