A virtual jailed shell environment for Go apps backed by an io/fs#FS.
docs(skills): add just-bash-port skill
Capture the workflow for porting commands from vercel-labs/just-bash
into kefka's command.Execer interface. The SKILL.md walks through
fetching the TS source, surveying kefka conventions, wiring
pborman/getopt/v2, matching just-bash output byte-for-byte, and
registering the command. Two reference files document the runtime
surface (ExecContext fields, billy filesystem, exit codes,
resolvePath) and a getopt/v2 cookbook that maps just-bash argDefs
onto Go flag primitives. Test writing is delegated to the
go-table-driven-tests skill.
Assisted-by: Claude Opus 4.7 via Claude Code
Signed-off-by: Xe Iaso <me@xeiaso.net>
+592
+269
.claude/skills/just-bash-port/SKILL.md
+269
.claude/skills/just-bash-port/SKILL.md
···
1
+
---
2
+
name: just-bash-port
3
+
description: Port a TypeScript command from vercel-labs/just-bash to a Go command.Execer in the kefka repo. Use when the user asks to "port" a just-bash command, references a just-bash source URL (raw.githubusercontent.com/vercel-labs/just-bash/...), or wants to add a new coreutil-style command (base64, cat, head, wc, etc.) to kefka.
4
+
---
5
+
6
+
# Porting a just-bash command to kefka
7
+
8
+
This skill ports a single TypeScript command from
9
+
`vercel-labs/just-bash` (Node-based busybox-like shell) into a Go
10
+
implementation that satisfies `tangled.org/xeiaso.net/kefka/command.Execer`.
11
+
Flag parsing uses `github.com/pborman/getopt/v2` (already an indirect
12
+
dependency of kefka).
13
+
14
+
## When to invoke
15
+
16
+
The user request typically looks like one of:
17
+
18
+
- "Port command https://raw.githubusercontent.com/vercel-labs/just-bash/.../<name>.ts ..."
19
+
- "Add a `<name>` command to kefka based on just-bash"
20
+
- "Reimplement the `<name>` coreutil in kefka"
21
+
22
+
If the user does not specify a flag-parsing library, default to
23
+
`github.com/pborman/getopt/v2`.
24
+
25
+
## Required reading before coding
26
+
27
+
Read these references **once** at the start of the port. They are short
28
+
and contain the surface-area knowledge needed to make safe choices:
29
+
30
+
- [references/execer-surface.md](references/execer-surface.md) — `command.Execer`
31
+
interface, `ExecContext` fields, exit-code conventions, the billy filesystem,
32
+
and the path-resolution helper used across kefka commands.
33
+
- [references/getopt-v2.md](references/getopt-v2.md) — how to wire
34
+
`pborman/getopt/v2`, how to set the usage line, how to expose `--help`,
35
+
and how to map TypeScript `parseArgs` flag definitions onto getopt
36
+
primitives.
37
+
38
+
## Port workflow
39
+
40
+
Follow these steps in order. Do not skip steps unless the user has said
41
+
the work is already done.
42
+
43
+
### 1. Fetch the source
44
+
45
+
```bash
46
+
curl -s https://raw.githubusercontent.com/vercel-labs/just-bash/refs/heads/main/packages/just-bash/src/commands/<name>/<name>.ts
47
+
```
48
+
49
+
Read it end-to-end. Note:
50
+
51
+
- the help block (name, summary, usage, options) — copy this verbatim into the Go usage func
52
+
- the `argDefs` object — each entry maps to one getopt flag
53
+
- positional args (`parsed.result.positional`) — accessed via `set.Args()` in Go
54
+
- whether stdin/files are read as binary (`readFileBuffer`) or as text
55
+
- the error/exit-code paths (`exitCode: 1`, `exitCode: 2`)
56
+
57
+
### 2. Survey the kefka conventions
58
+
59
+
Before writing code, skim two existing commands so the new one matches
60
+
the house style:
61
+
62
+
- `command/internal/hostname/hostname.go` — minimal `Execer`
63
+
- `command/internal/ls/ls.go` — full-featured command with flag
64
+
parsing, `resolvePath`, billy filesystem use, and exit-status
65
+
reporting
66
+
67
+
The reference file [references/execer-surface.md](references/execer-surface.md)
68
+
summarises both, but reading the actual files anchors the port to
69
+
current code.
70
+
71
+
### 3. Create the package
72
+
73
+
Layout:
74
+
75
+
```
76
+
command/internal/<name>/<name>.go
77
+
command/internal/<name>/<name>_test.go
78
+
```
79
+
80
+
Package naming rules:
81
+
82
+
- Use the command name (`base64`, `cat`, `wc`, ...) as the package name when it isn't a Go reserved word.
83
+
- For Go reserved words (`true`, `false`, `for`, ...), append `cmd` — e.g. `truecmd`, `falsecmd`. The directory name follows the package name.
84
+
- If the package name collides with a stdlib import you need (e.g. `encoding/base64`), import the stdlib under an alias (`enc "encoding/base64"`) rather than renaming the package — keeps the registry call site readable.
85
+
86
+
The file exports a single zero-value `Impl` type:
87
+
88
+
```go
89
+
type Impl struct{}
90
+
91
+
func (Impl) Exec(ctx context.Context, ec *command.ExecContext, args []string) error { ... }
92
+
```
93
+
94
+
### 4. Wire flag parsing with getopt/v2
95
+
96
+
See [references/getopt-v2.md](references/getopt-v2.md) for the full
97
+
recipe. The minimum for any port:
98
+
99
+
```go
100
+
set := getopt.New()
101
+
set.SetProgram("<name>")
102
+
set.SetParameters("[FILE]") // or whatever positional shape the help block declares
103
+
104
+
usage := func() {
105
+
fmt.Fprint(stderr, "Usage: <name> [OPTION]... [FILE]\n")
106
+
// ... copy the just-bash help block verbatim, one Fprint per line
107
+
}
108
+
set.SetUsage(usage)
109
+
110
+
decode := set.BoolLong("decode", 'd', "decode data")
111
+
help := set.BoolLong("help", 0, "display this help and exit")
112
+
113
+
if err := set.Getopt(append([]string{"<name>"}, args...), nil); err != nil {
114
+
fmt.Fprintf(stderr, "<name>: %s\n", err)
115
+
usage()
116
+
return interp.ExitStatus(1)
117
+
}
118
+
if *help {
119
+
usage()
120
+
return nil
121
+
}
122
+
```
123
+
124
+
Key gotchas:
125
+
126
+
- `set.Getopt` expects `args[0]` to be the program name. **Always** prefix
127
+
the user's args with the command name.
128
+
- Use rune `0` for "no short alias" (`BoolLong("help", 0, ...)`).
129
+
- `--help` is **not** automatic. Add it explicitly and check the bool
130
+
after parsing.
131
+
- The default usage prints to stderr; do not print help to stdout — that
132
+
breaks pipelines and matches GNU coreutils behavior.
133
+
134
+
### 5. Read input correctly
135
+
136
+
If the just-bash command reads files or stdin (most do), implement a
137
+
small helper that:
138
+
139
+
1. Reads `ec.Stdin` when `len(files) == 0` or `files == ["-"]`.
140
+
2. Otherwise concatenates each file via `ec.FS.Open(resolvePath(ec, file))`.
141
+
3. Treats `-` inside a file list as stdin.
142
+
4. Returns `interp.ExitStatus(1)` with a stderr message
143
+
(`"<name>: <file>: No such file or directory\n"`) on missing files —
144
+
match the just-bash exact string when possible.
145
+
146
+
The `resolvePath` helper is identical across kefka commands; copy it
147
+
verbatim from `command/internal/ls/ls.go`. It is small enough to keep
148
+
local rather than extracting to a shared package.
149
+
150
+
### 6. Match the just-bash output **byte-for-byte**
151
+
152
+
Subtle parity points to check against the TypeScript:
153
+
154
+
- **Trailing newline**: many just-bash commands emit a trailing newline
155
+
only when output is non-empty. Mirror this exactly.
156
+
- **Wrap behavior** (e.g. `base64 -w COLS`): wrap=0 disables wrapping
157
+
*and* suppresses the trailing newline.
158
+
- **Error format**: `<name>: <arg>: <reason>\n` is the standard. Do not
159
+
embed Go error wrapping (`%v` of an `*os.PathError`) into user-facing
160
+
stderr; substitute a fixed message that matches the just-bash output.
161
+
- **Exit codes**: `0` success, `1` invalid input or runtime error, `2`
162
+
usage error or missing file (matches GNU coreutils, which is what
163
+
just-bash imitates). Return via `interp.ExitStatus(uint8(code))`.
164
+
165
+
### 7. Register the command
166
+
167
+
Add the package to `command/registry/coreutils/coreutils.go`:
168
+
169
+
```go
170
+
import (
171
+
"tangled.org/xeiaso.net/kefka/command/internal/<name>"
172
+
// ... other imports, alphabetical
173
+
)
174
+
175
+
func Register(reg *registry.Impl) {
176
+
reg.Register("<name>", <pkg>.Impl{})
177
+
// ... other registrations, alphabetical
178
+
}
179
+
```
180
+
181
+
Keep both the import block and the `Register` body alphabetised — the
182
+
existing file does, and diffs stay clean that way.
183
+
184
+
### 8. Write tests
185
+
186
+
**Use the `go-table-driven-tests` skill for the test file.** Invoke it
187
+
explicitly before writing the test — it encodes the kefka test
188
+
conventions (struct table with `name`, `t.Run`, `t.Helper()` in
189
+
fixtures, `bytes.Buffer` for stdout/stderr capture) and saves you from
190
+
reinventing the layout.
191
+
192
+
Bare minimum coverage for any port:
193
+
194
+
- Encode/decode (or whatever the command's primary operation is) via
195
+
stdin
196
+
- The same operation via a file argument
197
+
- Empty input
198
+
- The `-` argument explicitly meaning stdin
199
+
- A round trip if the command has an inverse mode (e.g. encode+decode)
200
+
- Each declared flag exercised at least once
201
+
- `--help` prints the usage line to stderr and returns `nil`
202
+
- Unknown flag returns an error
203
+
- Missing file returns an error and writes the standard "No such file
204
+
or directory" stderr line
205
+
206
+
Build the in-memory billy filesystem with `memfs.New()` and seed it
207
+
with small fixture files. Pattern:
208
+
209
+
```go
210
+
func newFS(t *testing.T) billy.Filesystem {
211
+
t.Helper()
212
+
fs := memfs.New()
213
+
write := func(name string, data []byte) {
214
+
f, err := fs.OpenFile(name, os.O_CREATE|os.O_WRONLY, 0o644)
215
+
if err != nil { t.Fatal(err) }
216
+
f.Write(data)
217
+
f.Close()
218
+
}
219
+
write("hello.txt", []byte("hello"))
220
+
return fs
221
+
}
222
+
```
223
+
224
+
`command/internal/ls/ls_test.go` is the canonical example to mirror.
225
+
226
+
### 9. Verify
227
+
228
+
```bash
229
+
go mod tidy # promote getopt/v2 from indirect → direct if needed
230
+
go build ./...
231
+
go test ./command/internal/<name>/...
232
+
```
233
+
234
+
Pre-existing `go vet` failures elsewhere in the repo (e.g.
235
+
`wasm/billyfs`) are not introduced by the port — note them but do not
236
+
fix them as part of this task.
237
+
238
+
### 10. Report
239
+
240
+
Summarise to the user:
241
+
242
+
- the new package path and its registry entry
243
+
- which flags were implemented and any TS behaviour intentionally
244
+
omitted (e.g. browser fallbacks via `atob`/`btoa`, `Buffer`
245
+
detection — Go has neither concern)
246
+
- which tests were added
247
+
- any pre-existing repo issues observed but not addressed
248
+
249
+
## Things to deliberately drop
250
+
251
+
The just-bash sources contain Node/browser-specific scaffolding that
252
+
does **not** belong in the Go port:
253
+
254
+
- `if (typeof Buffer !== "undefined")` branches — Go has one bytes
255
+
type, use it
256
+
- `atob` / `btoa` / `String.fromCharCode` — use `encoding/base64`,
257
+
`bytes`, etc.
258
+
- `flagsForFuzzing` exports — kefka has no fuzz harness wired up for
259
+
these
260
+
- `stdoutEncoding: "binary"` markers — `io.Writer.Write([]byte)` is
261
+
already binary-safe
262
+
263
+
## Things to keep faithful to
264
+
265
+
- Help text wording
266
+
- Flag short/long names and defaults
267
+
- Exit codes and stderr format
268
+
- Trailing-newline rules
269
+
- Whether files concatenate (most do) or only the first is honoured
+159
.claude/skills/just-bash-port/references/execer-surface.md
+159
.claude/skills/just-bash-port/references/execer-surface.md
···
1
+
# kefka Execer surface area
2
+
3
+
Everything a port needs to know about the runtime contract a command
4
+
plugs into. Read once per port; do not duplicate this content into
5
+
SKILL.md.
6
+
7
+
## The interface
8
+
9
+
`tangled.org/xeiaso.net/kefka/command/command.go`:
10
+
11
+
```go
12
+
type ExecContext struct {
13
+
Stdin io.Reader
14
+
Stdout, Stderr io.Writer
15
+
Dir string // fsys-relative pwd
16
+
Environ expand.Environ // mvdan.cc/sh/v3/expand
17
+
FS billy.Filesystem
18
+
}
19
+
20
+
type Execer interface {
21
+
Exec(ctx context.Context, ec *ExecContext, args []string) error
22
+
}
23
+
```
24
+
25
+
`args` is **already stripped of `argv[0]`** — the registry has split
26
+
the command name off before calling `Exec`. Never assume `args[0]` is
27
+
the command name.
28
+
29
+
## Filesystem
30
+
31
+
`ec.FS` is a `github.com/go-git/go-billy/v5` filesystem, not
32
+
`io/fs.FS`. Differences from stdlib:
33
+
34
+
- `Open(name) (billy.File, error)` — note the return type
35
+
- `Stat(name) (os.FileInfo, error)` — yes, `os.FileInfo`, billy still
36
+
uses the legacy alias
37
+
- `OpenFile`, `ReadDir`, `Stat`, `Symlink` (for the `billy.Symlink`
38
+
capability check) all live on the interface
39
+
- For tests, use `github.com/go-git/go-billy/v5/memfs.New()`
40
+
41
+
A nil `ec.FS` is possible (some shell paths don't pass one). Guard:
42
+
43
+
```go
44
+
if ec.FS == nil {
45
+
return errors.New("<name>: ExecContext has no filesystem")
46
+
}
47
+
```
48
+
49
+
…or, if the command is fine without one (e.g. reads only stdin), just
50
+
gate the file-reading branch.
51
+
52
+
## Path resolution
53
+
54
+
Every command that touches `ec.FS` needs the same `resolvePath`
55
+
helper. Copy it verbatim from `command/internal/ls/ls.go`:
56
+
57
+
```go
58
+
func resolvePath(ec *command.ExecContext, p string) string {
59
+
dir := ec.Dir
60
+
if dir == "" {
61
+
dir = "."
62
+
}
63
+
if path.IsAbs(p) {
64
+
p = strings.TrimPrefix(p, "/")
65
+
if p == "" {
66
+
return "."
67
+
}
68
+
return path.Clean(p)
69
+
}
70
+
joined := path.Join(dir, p)
71
+
if joined == "" {
72
+
return "."
73
+
}
74
+
return joined
75
+
}
76
+
```
77
+
78
+
Why: shell-absolute paths like `/foo` map to fsys-relative `foo`, and
79
+
relative paths join against `ec.Dir`. The registry's `Resolve` does
80
+
similar work but on a different layer (pwd state) — it does **not**
81
+
rewrite paths before they reach `Exec`.
82
+
83
+
## Exit codes
84
+
85
+
Return one of:
86
+
87
+
- `nil` — exit code 0
88
+
- `interp.ExitStatus(uint8(code))` from `mvdan.cc/sh/v3/interp` —
89
+
arbitrary nonzero
90
+
- a Go `error` — propagated as exit code 1 with the error printed by
91
+
the shell
92
+
93
+
Convention used by `ls` and matched by GNU coreutils:
94
+
95
+
| Code | Meaning |
96
+
|------|---------|
97
+
| 0 | success |
98
+
| 1 | runtime error (invalid input, bad data) |
99
+
| 2 | usage error (unknown flag, missing file) |
100
+
| 127 | command not found (registry, not commands) |
101
+
102
+
To pair an error with an exit code, wrap with `errors.Join`:
103
+
104
+
```go
105
+
return errors.Join(err, interp.ExitStatus(2))
106
+
```
107
+
108
+
## I/O patterns
109
+
110
+
- **`stdout` and `stderr` may be nil.** Defend with `io.Discard`:
111
+
112
+
```go
113
+
stdout := ec.Stdout
114
+
if stdout == nil { stdout = io.Discard }
115
+
```
116
+
117
+
- **`stdin` may be nil too.** Treat nil stdin as empty input, not as
118
+
an error.
119
+
120
+
- Write bytes with `io.Writer.Write([]byte)` for binary-safe output;
121
+
use `io.WriteString` or `fmt.Fprint`/`fmt.Fprintf` for text.
122
+
123
+
- Do **not** add trailing newlines unconditionally. Match the
124
+
just-bash command's exact behavior — many emit a trailing newline
125
+
only when output is non-empty.
126
+
127
+
## Reference implementations to mirror
128
+
129
+
| File | Why read it |
130
+
|------|-------------|
131
+
| `command/internal/hostname/hostname.go` | Smallest possible Execer; shows nil-guard pattern. |
132
+
| `command/internal/truecmd/truecmd.go` | Returns nil on success. |
133
+
| `command/internal/falsecmd/falsecmd.go` | Returns `interp.ExitStatus(1)`; package-name workaround for Go reserved word. |
134
+
| `command/internal/ls/ls.go` | Full pattern: flag parsing, path resolution, billy filesystem use, multi-mode output, exit-status reporting. |
135
+
| `command/internal/ls/ls_test.go` | Canonical table-driven test layout for a command. |
136
+
137
+
## Registration
138
+
139
+
Every command is registered exactly once in
140
+
`command/registry/coreutils/coreutils.go`. Both the imports and the
141
+
`reg.Register` calls are alphabetised — keep that.
142
+
143
+
```go
144
+
import (
145
+
"tangled.org/xeiaso.net/kefka/command/internal/base64"
146
+
"tangled.org/xeiaso.net/kefka/command/internal/falsecmd"
147
+
// ...
148
+
)
149
+
150
+
func Register(reg *registry.Impl) {
151
+
reg.Register("base64", base64.Impl{})
152
+
reg.Register("false", falsecmd.Impl{})
153
+
// ...
154
+
}
155
+
```
156
+
157
+
The registry calls `Exec` with an `ExecContext` it builds from the
158
+
shell's `interp.HandlerCtx(ctx)` — so the contract above is what the
159
+
real runtime delivers.
+164
.claude/skills/just-bash-port/references/getopt-v2.md
+164
.claude/skills/just-bash-port/references/getopt-v2.md
···
1
+
# pborman/getopt/v2 cookbook
2
+
3
+
The just-bash sources use a custom `parseArgs` shape; map it onto
4
+
`github.com/pborman/getopt/v2` using the patterns below.
5
+
6
+
## Setup
7
+
8
+
```go
9
+
import "github.com/pborman/getopt/v2"
10
+
11
+
set := getopt.New()
12
+
set.SetProgram("<name>")
13
+
set.SetParameters("[FILE]") // shows up after Usage: <name> [opts]
14
+
set.SetUsage(usage) // function called on parse errors
15
+
```
16
+
17
+
`getopt.New()` returns a fresh `*Set`; never use the package-level
18
+
default (`getopt.Bool`, `getopt.Parse`) inside an `Execer` because those
19
+
mutate global state shared across calls.
20
+
21
+
## Mapping just-bash flag types
22
+
23
+
| just-bash `argDefs` | getopt/v2 method |
24
+
|---------------------|---------------------------------------------------------------|
25
+
| `type: "boolean"` | `set.BoolLong(long, short, helpvalue)` |
26
+
| `type: "number"` | `set.IntLong(long, short, default, helpvalue)` |
27
+
| `type: "string"` | `set.StringLong(long, short, default, helpvalue)` |
28
+
| `type: "string[]"` | `set.ListLong(long, short, helpvalue)` (returns `*[]string`) |
29
+
| short-only | drop the long form, use `set.Bool(rune, helpvalue)` etc. |
30
+
| long-only | pass rune `0` for the short-name argument |
31
+
32
+
All `*Long` methods return a pointer; dereference after parsing.
33
+
34
+
## Parsing
35
+
36
+
```go
37
+
err := set.Getopt(append([]string{"<name>"}, args...), nil)
38
+
```
39
+
40
+
- `args[0]` must be the program name. The user's args (which already
41
+
have `argv[0]` stripped by the kefka registry) need a synthetic
42
+
prefix.
43
+
- `nil` for the second arg = "no per-option callback".
44
+
- On parse failure `err` is non-nil and getopt has *already* called the
45
+
usage function once. You typically want to print a one-line error
46
+
prefix (`"<name>: <err>"`) and return `interp.ExitStatus(1)` (or
47
+
`2` for usage errors — pick one and stay consistent inside the file).
48
+
49
+
```go
50
+
if err := set.Getopt(append([]string{"<name>"}, args...), nil); err != nil {
51
+
fmt.Fprintf(stderr, "<name>: %s\n", err)
52
+
usage()
53
+
return interp.ExitStatus(1)
54
+
}
55
+
```
56
+
57
+
## Usage function
58
+
59
+
`SetUsage(func())` overrides what getopt prints on error. Write the
60
+
usage text by hand instead of relying on `set.PrintUsage` — the
61
+
auto-formatter aligns columns differently from the just-bash source,
62
+
and the goal of the port is byte-for-byte parity with the TS help.
63
+
64
+
```go
65
+
usage := func() {
66
+
fmt.Fprint(stderr, "Usage: <name> [OPTION]... [FILE]\n")
67
+
fmt.Fprint(stderr, "<one-line summary copied from the TS help block>\n\n")
68
+
fmt.Fprint(stderr, " -d, --decode decode data\n")
69
+
fmt.Fprint(stderr, " -w, --wrap=COLS wrap encoded lines after COLS character (default 76, 0 to disable)\n")
70
+
fmt.Fprint(stderr, " --help display this help and exit\n")
71
+
}
72
+
set.SetUsage(usage)
73
+
```
74
+
75
+
Always print to **stderr**, not stdout — pipelines should not be
76
+
poisoned by help text.
77
+
78
+
## Help flag
79
+
80
+
`getopt/v2` does not auto-handle `--help`. Add it explicitly:
81
+
82
+
```go
83
+
help := set.BoolLong("help", 0, "display this help and exit")
84
+
// ... after parse:
85
+
if *help {
86
+
usage()
87
+
return nil
88
+
}
89
+
```
90
+
91
+
Use rune `0` to mean "no short alias" — `-h` typically aliases
92
+
`--human-readable` in coreutils-style commands, so leaving it free is
93
+
correct.
94
+
95
+
## Positionals
96
+
97
+
After `Getopt` succeeds, `set.Args()` returns the leftover positional
98
+
arguments. This is the equivalent of just-bash's
99
+
`parsed.result.positional`.
100
+
101
+
```go
102
+
files := set.Args()
103
+
```
104
+
105
+
## Mixed short/long combinations the parser accepts
106
+
107
+
Per the package docs:
108
+
109
+
- `-d` / `--decode` (single bool)
110
+
- `-dw 10` (combined: `-d` flag + `-w 10`)
111
+
- `-w10` / `-w 10` / `--wrap=10` / `--wrap 10` (all equivalent)
112
+
- `--` ends option parsing; everything after is positional
113
+
114
+
Tests should cover at least the long-form (`--wrap=10`) and
115
+
short-with-value (`-w 10`) variants if the command takes values, since
116
+
those are the two forms most likely to be wired wrong.
117
+
118
+
## Avoid
119
+
120
+
- `getopt.Parse()` (package-level) — mutates global state, breaks
121
+
re-entrancy
122
+
- `set.SetOptional()` — needed only for value-optional flags, which
123
+
just-bash never uses
124
+
- Calling `set.PrintUsage` from inside `usage` — it produces a
125
+
different layout than the TS help, defeating the whole point of
126
+
setting a custom usage function
127
+
128
+
## Example end-to-end
129
+
130
+
For a hypothetical `wc -lwc [FILE]...`:
131
+
132
+
```go
133
+
set := getopt.New()
134
+
set.SetProgram("wc")
135
+
set.SetParameters("[FILE]...")
136
+
137
+
usage := func() {
138
+
fmt.Fprint(stderr, "Usage: wc [OPTION]... [FILE]...\n")
139
+
fmt.Fprint(stderr, "Print newline, word, and byte counts for each FILE.\n\n")
140
+
fmt.Fprint(stderr, " -c, --bytes print the byte counts\n")
141
+
fmt.Fprint(stderr, " -l, --lines print the newline counts\n")
142
+
fmt.Fprint(stderr, " -w, --words print the word counts\n")
143
+
fmt.Fprint(stderr, " --help display this help and exit\n")
144
+
}
145
+
set.SetUsage(usage)
146
+
147
+
bytesFlag := set.BoolLong("bytes", 'c', "print the byte counts")
148
+
linesFlag := set.BoolLong("lines", 'l', "print the newline counts")
149
+
wordsFlag := set.BoolLong("words", 'w', "print the word counts")
150
+
help := set.BoolLong("help", 0, "display this help and exit")
151
+
152
+
if err := set.Getopt(append([]string{"wc"}, args...), nil); err != nil {
153
+
fmt.Fprintf(stderr, "wc: %s\n", err)
154
+
usage()
155
+
return interp.ExitStatus(1)
156
+
}
157
+
if *help {
158
+
usage()
159
+
return nil
160
+
}
161
+
162
+
files := set.Args()
163
+
_ = bytesFlag; _ = linesFlag; _ = wordsFlag; _ = files
164
+
```