Metadata-Version: 2.4
Name: get-engineering-done
Version: 0.1.3
Summary: Get Engineering Done: structured agentic workflows for engineering programs
Author: Englund Garage
License-Expression: Apache-2.0
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Science/Research
Classifier: Programming Language :: Python :: 3.11
Classifier: Topic :: Scientific/Engineering
Requires-Python: >=3.11
Description-Content-Type: text/markdown
License-File: LICENSE
Provides-Extra: dev
Requires-Dist: pytest>=8; extra == "dev"
Requires-Dist: pytest-timeout>=2.3; extra == "dev"
Provides-Extra: mutation
Requires-Dist: mutmut<3,>=2.4; extra == "mutation"
Requires-Dist: coverage>=7; extra == "mutation"
Dynamic: license-file

# Get Engineering Done (GED)

Get Engineering Done is a command-workflow scaffold for engineering programs
that need more structure than a one-off chat or notebook. It is
engineering-specific from the start.

GED provides a complete engineering workflow command surface and capability
set. It targets capability completeness: every capability an engineering
program needs to go from objective to reviewable, verified package has an
explicit home in GED.

GED turns an engineering objective into a reviewable workflow:

```text
formulate -> architect -> plan -> execute -> verify -> package
```

The first goal is not to fake a solver or a green result. The first goal is to
make an engineering project reviewable: requirements, interfaces, discipline
models, solver evidence, verification verdicts, provenance, and acceptance
criteria all have explicit homes.

## Quick Start

Install the runtime command surface (Claude Code, Codex, Gemini CLI, OpenCode)
straight from npm — no checkout required:

```bash
npx -y get-engineering-done --claude --local
```

Use `--codex`, `--gemini`, `--opencode`, or `--all` for the other supported
runtimes, and `--global` to write into the user-level config dir. The installer
writes model-visible GED command files into the selected runtime config target.
(From a source checkout, the equivalent is `node bin/install.js --claude --local`.)

Install the Python CLI from PyPI:

```bash
python -m pip install get-engineering-done
ged --help
```

> No account or API key is required for the core workflow — scaffolding,
> validation, the goal gate, and numerical verification all run offline. A
> `VVUQ_API_KEY` is optional and only enables the VVUQ knowledge-graph reuse and
> server-side claim verification.

Create a draft engineering project:

```bash
ged new-project \
  --root /path/to/project \
  --objective "Produce a coupled coherent PIC transceiver model" \
  --domain "photonic transceiver engineering"
```

Validate the scaffold:

```bash
ged validate --root /path/to/project
```

Strict validation is intentionally harder. A new scaffold is a draft; it does
not pass strict validation until phase artifacts are present, nonempty,
format-checked, marked available in the phase manifest, and paired with
matching hash/provenance metadata. Strict validation does not prove engineering
truth; it checks that a package is reviewable and not an obvious placeholder.

```bash
ged validate --root /path/to/project --strict
```

## Runtime Commands

GED is designed to expose the same command loop across AI runtimes:

| Runtime | Help | New project |
| --- | --- | --- |
| Codex | `$ged-help` | `$ged-new-project` |
| Claude Code | `/ged:help` | `/ged:new-project` |
| Gemini CLI | `/ged:help` | `/ged:new-project` |
| OpenCode | `/ged-help` | `/ged-new-project` |

The local CLI can print the full command map:

```bash
ged command-map --runtime codex
```

## Capability completeness

GED tracks its engineering capability set as an executable requirement:

```bash
ged capabilities
```

This command returns non-zero until every required engineering capability is
present. See [docs/capability-requirement.md](docs/capability-requirement.md).

## Template Curation (STEM)

GED can curate STEM-ready templates for agent use and emit Neo4j-shared ingest
artifacts:

```bash
# --workspace-root defaults to the current working directory; --output-root
# defaults to ./artifacts/template-curation
ged curate-templates
```

Or with explicit paths:

```bash
ged curate-templates \
  --workspace-root /path/to/workspace \
  --output-root /path/to/output
```

Install a 30-minute launchd schedule (macOS):

```bash
ged install-curation-schedule \
  --workspace-root /path/to/workspace \
  --output-root /path/to/output \
  --interval-minutes 30
```

The plist defaults to
`~/Library/LaunchAgents/com.englund-garage.ged.template-curator.plist`;
override with `--plist-path` if you prefer a different location.

## Project Shape

GED creates:

```text
GED/
  PROJECT.md
  REQUIREMENTS.md
  ROADMAP.md
  STATE.md
  phases/
    phase-01/
      PLAN.md
      VERIFY.md
      outputs/
        README.md
        artifact_manifest.json
```

The manifest starts with planned artifacts only. Real engineering outputs must
be added by the owning project before the phase can move from draft to green.

## Engineering Bias

GED is for engineering programs where success depends on interfaces,
tolerances, physical constraints, cost or manufacturability, simulation
evidence, tests, and reviewable provenance. For the initial coherent PIC
transceiver use case, GED should sit above OpenMDAO/MPhys, discipline backends
such as Tidy3D/SAX/SPICE/gdsfactory/Femwell, VVUQ claim checks, Neo4j
provenance, and work-contract acceptance gates.

## Development

```bash
python3.11 -m pytest -q
```
