AI-Native Binariesv1.0.0

🧵astwire gives AI the context it needs.

Don’t give AI more code. Give AI better code context.

LLMs reason about software remarkably well — once you’ve decided how much of the codebase to hand them. Paste too little and the model guesses at interfaces it can’t see; paste everything and the signal drowns in tests, migrations, and build noise. astwire sits between your source tree and the prompt: it traces real internal dependencies across Python, JavaScript, TypeScript, and Go — and packs two dozen other languages as-is — keeping the structure that matters, stripping what doesn’t, and producing a lean, partitionable bundle built for LLM reasoning, entirely on your machine.

Zero

Cloud Round-Trips

80%+

Token Reduction (skeleton mode)

Output Formats

AOT

Ahead-of-Time Compiled

View Source Documentation

astwire.sh

Live

Language Capabilities

$astwire --languages

AOT compiled · no runtime required · runs anywhere

What's New

Why It Exists

Blind directory dumps hand the model tests, migrations, build artifacts, and unrelated files right alongside the code that actually matters — more tokens, more noise, less useful context.
Formatting waste — trailing whitespace, redundant blank lines, inconsistent line endings — looks trivial in one file and adds up to real token cost at repository scale.
Handing over an isolated target file hides the dependency chain behind it, forcing the model to guess at signatures and internal types it was never shown.

Not every line in your repo belongs in the prompt.

What the model actually needs

Classes, functions & their signatures
Type annotations & docstrings
The real internal dependency chain
The config & utilities it touches

What it doesn’t

Thousands of lines of tests
Migrations & generated artifacts
Documentation unrelated to the change
Blank lines & formatting noise

One deliberately constructed context

Why astwire

Recursive Import Tracing: A CLI rarely exists in isolation — it imports a service, which imports config, which depends on another module. astwire statically traces that chain from any file or directory root, without executing code (`-i`), so the model gets the surrounding architecture instead of one file in a vacuum.
Symbol Skeletonization: Sometimes the model needs to know which classes, methods, and functions exist — not their full implementation. `--skeleton` empties bodies into `...` while preserving docstrings, signatures, and type annotations: over 80% token reduction with the architectural information kept intact.
Deterministic Cleansing: astwire never asks an AI model to decide what whitespace to remove. Trailing whitespace, repeated blank lines, and inconsistent line endings are stripped by deterministic, repeatable rules (`--strip-waste`) — not a probabilistic guess.
Partitioned Budgets: Even optimized, some codebases don’t fit one request. `--max-tokens` imposes a ceiling and partitions the output across deterministic chunks without ever splitting a single file across two partitions.
Know What You’re Saving: The `--analysis` dry run reports token counts, waste lines, waste bytes, and recoverable percentage per file — turning "trust me, it’s optimized" into a number you can actually inspect before you commit to a bundle.
Secret Redaction: Codebases contain things that should never reach a prompt. Pattern-based redaction masks private keys, bearer tokens, API credentials, and connection strings before anything is bundled — reducing the chance sensitive configuration leaks into an LLM context.
Ahead-of-Time Compiled: Every release is compiled ahead-of-time (AOT) to a native executable per platform — no Python interpreter, no bytecode cache, no cold-start penalty. Download the binary and run it.

One Artifact. Every Workflow.

One deliberately constructed context

Coding AgentsLLM PromptsCode Review ToolsDocumentation SystemsCustom AI Pipelines

Installation

Ships as a single ahead-of-time (AOT) compiled binary for every major platform — compiled straight to native machine code, so there's no interpreter, no dependency tree, and no runtime to install.

Installs the ahead-of-time (AOT) compiled binary directly — no build step, no Python interpreter required on the target machine. Omit the version to install the latest release; pass a version tag to pin an exact version instead.

macOS & Linux (bash)

curl -fsSL https://install.djangoplay.org/astwire | bash

Windows (PowerShell)

irm https://install.djangoplay.org/astwire.ps1 | iex

macOS & Linux — install a specific version

curl -fsSL https://install.djangoplay.org/astwire | bash -s -- v0.1.0

Windows — install a specific version

$env:ASTWIRE_VERSION = "v0.1.0"; irm https://install.djangoplay.org/astwire.ps1 | iex

Upgrade

Re-running install again cleanly overwrites the existing binary — no uninstall needed first.
Binary installation proceeds to default install location `~/.local/bin`.
Windows: the installer overwrites astwire.exe in $env:LOCALAPPDATA\Programs\astwire.

CLI References

targetsOne or more target files/directories to process, space-separated (default: current directory).

--targets PATH [PATH ...]Same as the positional targets — e.g. astwire --skeleton --targets src/ is valid.

-i, --resolve-importsFollow local imports from supported languages (Python, JS/TS, Go).

--languagesPrint the language capability table and exit.

--lang NAME[,NAME]Only include these languages, by name or extension, comma-separated.

--analysisDry-run audit displaying recoverable token waste per file, broken out by language, without writing files.

--strip-wasteScrub trailing whitespace and collapse empty lines.

--skeletonStrip function/method bodies in languages that support skeletonization, preserving signatures and docstrings.

--since REFSeed context from files changed since this git ref instead of the given targets (tracked + untracked, gitignore-aware). Combine with -i to also pull in what the changed files import.

--max-depth NWith -i, exclude files more than N import-hops from a seed (manifests like package.json/go.mod are always kept). No effect without -i.

--decay-depth NWith -i, skeletonize files more than N import-hops from a seed, even without --skeleton. No effect without -i.

--graphWith -i, emit a dependency-graph block of edges between bundled files before the file contents.

--max-tokens NCeiling for token budget per output partition.

-f, --format {markdown,llm,json}Output format (default: llm). Inferred from the -o extension if omitted.

-o, --output DESTDestination context file (default: context.xml). .md/.json/.xml infer the format.

-v, --versionShow program’s version number and exit.

--uninstallCompletely remove the astwire binary and associated local configuration files.

Security & Privacy

Local execution — astwire parses every supported language with static, non-executing parsers (Python’s AST module, and equivalent static parsers for JS/TS/Go and beyond); no code is uploaded or executed.
Secret redaction — automated pattern matching masks private keys, bearer headers, tokens, and database passwords before bundling.
Gitignore-compliant — honors `.gitignore` exclusion hierarchies automatically.

Don’t give AI your entire codebase.

Give it the context it actually needs.

Dependency-aware. Token-efficient. Local-first. Built for AI-native software engineering.

View Source