fracode 0.1.6

Stack-based scaffolding tool for application projects

FraCode

FraCode is a stack-based scaffolding tool.

It generates application projects that use official ecosystem libraries directly, starting with a standalone FastAPI stack today and leaving room for other languages and frameworks over time.

What FraCode Is

FraCode is not trying to replace FastAPI.

FraCode is meant to help you start faster by generating:

• a clean project layout
• stack-aware scaffolds
• file generators for common app pieces
• lightweight development commands
• code you can fully own after generation

The guiding rule is simple:

• zero import fracode in generated application code
• zero FraCode runtime dependency in generated projects
• official framework and library imports only

FraCode builds the house, then gets out of the way.

Available Stacks

Current built-in stack:

• python/fastapi - standalone FastAPI application with typed settings, SQLAlchemy, Alembic, Docker, and pytest

List stacks with:

fra stacks

Quick Start

Prerequisites:

• Python 3.12+
• Poetry for the default generated-project workflow

pip install fracode

fra new my-app --stack python/fastapi
cd my-app

poetry install
fra serve

Then open http://127.0.0.1:8000/docs.

The generated FastAPI app is standard application code, so you are not locked into Poetry. If you prefer, you can manage dependencies yourself with pip and a virtual environment.

You can also run the generated app directly:

python dev.py

What The FastAPI Stack Generates

The default FastAPI scaffold produces a normal project structure like:

• app/main.py - FastAPI entrypoint
• app/api/routes.py - route registration and healthcheck
• app/core/config.py - typed settings
• app/core/errors.py - project-owned exception handlers
• app/core/logging.py - project-owned logging setup
• app/db/ - SQLAlchemy base and session helpers
• app/schemas/ - Pydantic schemas
• migrations/ and alembic.ini - migration support
• Dockerfile and docker-compose.yml - container setup
• tests/ - starter test suite
• dev.py - local dev runner

This is application code, not a FraCode runtime wrapper.

CLI

Core commands:

• fra new <name> creates a new project from a stack
• fra stacks lists available language/framework stacks
• fra serve runs a generated app by detecting app/main.py or main.py
• fra make:controller <Name> generates a stack-aware controller and schema
• fra make:model <Name> generates a stack-aware model

Examples:

fra new blog --stack python/fastapi
fra make:controller User --api
fra make:model User

For the FastAPI stack, controller generation also wires the new controller into app/api/routes.py and creates a matching schema module in app/schemas/.

Development

poetry install --with dev
pytest
ruff check fracode/ tests/
ruff format --check fracode/ tests/
mypy fracode/

Multi-Stack Direction

FraCode is built around stack discovery instead of one framework-specific runtime.

The intended shape is:

• templates/stacks/<language>/<framework>/...
• each stack defines its own metadata and generators
• the CLI discovers stacks dynamically
• generated apps stay native to their own ecosystem

That means FraCode can grow toward things like:

• python/flask
• typescript/express
• go/chi

without forcing those ecosystems through one shared abstraction layer.

Roadmap

FraCode currently ships with one built-in production-ready stack:

• python/fastapi

Planned directions for future stacks include:

• python/flask
• typescript/express
• go/chi

The goal is to add new stacks without introducing a shared runtime dependency into generated apps.

Contributing

Contributions are welcome:

• new stack support
• better project templates
• generator ergonomics
• documentation
• stronger day-zero scaffolds for real app work

License

FraCode is open-source software licensed under the MIT license.