hub-codegen 0.1.0

Multi-language code generator for Hub plugins from Synapse IR
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

# Docker Development Setup

Simple Docker setup for developing with Substrate, Synapse, and hub-codegen.

## Quick Start

Assuming you have this directory structure:

```
hypermemetic/
├── substrate/       # Substrate source
├── synapse/         # Synapse source
└── hub-codegen/     # This repo
```

### Build the image

```bash
docker build -t hub-codegen:dev .
```

### Run the full pipeline

```bash
# Using docker-compose (easiest)
docker-compose run dev

# Or with docker directly
docker run -v $(pwd)/../substrate:/workspace/substrate \
           -v $(pwd)/../synapse:/workspace/synapse \
           -v $(pwd)/output:/workspace/output \
           hub-codegen:dev dev rust
```

This will:
1. Build substrate (if needed)
2. Build synapse (if needed)
3. Start substrate
4. Use synapse to fetch IR
5. Generate Rust client code
6. Save output to `./output`

## Available Commands

### `dev [lang]` - Full pipeline

```bash
docker-compose run dev        # Generate Rust client
docker-compose run dev rust   # Generate Rust client
docker-compose run dev typescript  # Generate TypeScript client
```

### `substrate` - Run substrate server

```bash
docker run -p 44410:44410 \
           -v $(pwd)/../substrate:/workspace/substrate \
           hub-codegen:dev substrate
```

### `synapse` - Run synapse CLI

```bash
docker run -v $(pwd)/../synapse:/workspace/synapse \
           --network host \
           hub-codegen:dev synapse -P 44410 substrate -i > ir.json
```

### `generate` - Run hub-codegen

```bash
docker run -v $(pwd)/ir.json:/tmp/ir.json \
           -v $(pwd)/output:/workspace/output \
           hub-codegen:dev generate /tmp/ir.json -o /workspace/output -t rust
```

### `bash` - Interactive shell

```bash
docker-compose run shell

# Or
docker run -it \
           -v $(pwd)/../substrate:/workspace/substrate \
           -v $(pwd)/../synapse:/workspace/synapse \
           hub-codegen:dev bash
```

## Directory Structure

```
/workspace/
├── substrate/          # Your substrate source (mounted)
├── synapse/            # Your synapse source (mounted)
├── hub-codegen/        # Built into image
└── output/             # Generated code (mounted)
```

## Building from Source

The Dockerfile builds hub-codegen at image build time. Substrate and synapse are built on first run if needed.

To rebuild everything:

```bash
# Rebuild image
docker build --no-cache -t hub-codegen:dev .

# Remove built binaries to force rebuild
rm -rf ../substrate/target/release/substrate
rm -rf ~/.cabal/bin/synapse

# Run again
docker-compose run dev
```

## Development Workflow

```bash
# 1. Make changes to substrate or synapse source
vim ../substrate/src/main.rs

# 2. Remove the binary to force rebuild
rm ../substrate/target/release/substrate

# 3. Run the pipeline
docker-compose run dev

# 4. Check the generated code
ls -la output/
```

## Troubleshooting

**Q: Builds are slow**

A: Mount cargo cache and cabal cache:

```yaml
volumes:
  - ../substrate:/workspace/substrate
  - ../synapse:/workspace/synapse
  - cargo-cache:/root/.cargo/registry
  - cabal-cache:/root/.cabal
```

**Q: Source not found**

A: Adjust paths in docker-compose.yml to match your directory structure.

**Q: Permission errors**

A: The container runs as root. Output files will be owned by root. Either run `sudo chown -R $USER output/` or add a user to the Dockerfile.