[READ-ONLY] Mirror of https://github.com/bombshell-dev/docs.
bomb.sh/docs
docs(tab): fix wrong code examples (#21)
* docs(tab): fix wrong code examples
* docs: fix wrong updating for commander examples
authored by
kazuya kawaguchi
and committed by
GitHub
(Sep 29, 2025, 3:33 AM -0500)
6d73d212
0e287262
+102
-120
+13
-13
src/content/docs/tab/api/core.mdx
+13
-13
src/content/docs/tab/api/core.mdx
···
43
43
Adds a global option to the root command.
44
44
45
45
**Parameters:**
46
-
- `name` (string): The option name (e.g., '--config')
46
+
- `name` (string): The option name (e.g., 'config' for '--config')
47
47
- `description` (string): Option description
48
48
- `handler` (OptionHandler, optional): Function that provides completion suggestions
49
49
- `alias` (string, optional): Short flag alias (e.g., 'c' for '--config')
···
52
52
53
53
**Example:**
54
54
```ts
55
-
t.option('--config', 'Use specified config file', function(complete) {
55
+
t.option('config', 'Use specified config file', function(complete) {
56
56
complete('vite.config.ts', 'Vite config file');
57
57
complete('vite.config.js', 'Vite config file');
58
58
}, 'c');
···
120
120
Adds an option to this command.
121
121
122
122
**Parameters:**
123
-
- `name` (string): The option name (e.g., '--port')
123
+
- `name` (string): The option name (e.g., 'p' for '--port')
124
124
- `description` (string): Option description
125
125
- `handler` (OptionHandler, optional): Function that provides completion suggestions
126
126
- `alias` (string, optional): Short flag alias (e.g., 'p' for '--port')
···
129
129
130
130
**Example:**
131
131
```ts
132
-
cmd.option('--port', 'Port number', function(complete) {
132
+
cmd.option('port', 'Port number', function(complete) {
133
133
complete('3000', 'Development port');
134
134
complete('8080', 'Production port');
135
135
}, 'p');
···
279
279
const t = new RootCommand();
280
280
281
281
// Add global options
282
-
t.option('--config', 'Use specified config file', function(complete) {
282
+
t.option('config', 'Use specified config file', function(complete) {
283
283
complete('vite.config.ts', 'Vite config file');
284
284
complete('vite.config.js', 'Vite config file');
285
285
}, 'c');
286
286
287
-
t.option('--mode', 'Set env mode', function(complete) {
287
+
t.option('mode', 'Set env mode', function(complete) {
288
288
complete('development', 'Development mode');
289
289
complete('production', 'Production mode');
290
290
}, 'm');
···
297
297
298
298
// Add commands with completions
299
299
const devCmd = t.command('dev', 'Start development server');
300
-
devCmd.option('--port', 'Port number', function(complete) {
300
+
devCmd.option('port', 'Port number', function(complete) {
301
301
complete('3000', 'Development port');
302
302
complete('8080', 'Production port');
303
303
}, 'p');
304
304
305
-
devCmd.option('--host', 'Hostname', function(complete) {
305
+
devCmd.option('host', 'Hostname', function(complete) {
306
306
complete('localhost', 'Localhost');
307
307
complete('0.0.0.0', 'All interfaces');
308
308
}, 'H');
309
309
310
-
devCmd.option('--verbose', 'Enable verbose logging', 'v');
310
+
devCmd.option('verbose', 'Enable verbose logging', 'v');
311
311
312
312
// Add nested commands
313
313
t.command('dev build', 'Build project');
···
356
356
Make your completions responsive to what the user is typing:
357
357
358
358
```ts
359
-
devCmd.option('--port', 'Port number', function(complete) {
359
+
devCmd.option('port', 'Port number', function(complete) {
360
360
// Check if user is typing a specific port
361
361
if (this.toComplete?.startsWith('30')) {
362
362
complete('3000', 'Development port');
···
374
374
Load completions from external sources:
375
375
376
376
```ts
377
-
devCmd.option('--config', 'Config file', async function(complete) {
377
+
devCmd.option('config', 'Config file', async function(complete) {
378
378
try {
379
379
const files = await fs.readdir('.');
380
380
const configFiles = files.filter(f => f.includes('config'));
···
391
391
For boolean flags, you don't need a handler:
392
392
393
393
```ts
394
-
devCmd.option('--verbose', 'Enable verbose logging', 'v');
395
-
devCmd.option('--quiet', 'Suppress output');
394
+
devCmd.option('verbose', 'Enable verbose logging', 'v');
395
+
devCmd.option('quiet', 'Suppress output');
396
396
```
397
397
398
398
## Next Steps
+4
-4
src/content/docs/tab/basics/getting-started.mdx
+4
-4
src/content/docs/tab/basics/getting-started.mdx
···
39
39
const t = new RootCommand();
40
40
41
41
// Add global options
42
-
t.option('--config', 'Use specified config file', function(complete) {
42
+
t.option('config', 'Use specified config file', function(complete) {
43
43
complete('vite.config.ts', 'Vite config file');
44
44
complete('vite.config.js', 'Vite config file');
45
45
}, 'c');
46
46
47
47
// Add commands with completions
48
48
const devCmd = t.command('dev', 'Start development server');
49
-
devCmd.option('--port', 'Port number', function(complete) {
49
+
devCmd.option('port', 'Port number', function(complete) {
50
50
complete('3000', 'Development port');
51
51
complete('8080', 'Production port');
52
52
}, 'p');
53
53
54
-
devCmd.option('--host', 'Hostname', function(complete) {
54
+
devCmd.option('host', 'Hostname', function(complete) {
55
55
complete('localhost', 'Localhost');
56
56
complete('0.0.0.0', 'All interfaces');
57
57
}, 'H');
···
108
108
Add options to commands with completion handlers:
109
109
110
110
```ts
111
-
devCmd.option('--port', 'Port number', function(complete) {
111
+
devCmd.option('port', 'Port number', function(complete) {
112
112
complete('3000', 'Development port');
113
113
complete('8080', 'Production port');
114
114
}, 'p'); // Short flag alias
+19
-27
src/content/docs/tab/guides/adapters.mdx
+19
-27
src/content/docs/tab/guides/adapters.mdx
···
15
15
16
16
const cli = cac('my-cli');
17
17
18
-
cli.command('dev', 'Start dev server').option('--port <port>', 'Specify port');
19
-
cli.command('build', 'Build for production').option('--mode <mode>', 'Build mode');
18
+
cli.command('dev', 'Start dev server').option('port <port>', 'Specify port');
19
+
cli.command('build', 'Build for production').option('mode <mode>', 'Build mode');
20
20
21
-
const completion = tab(cli);
21
+
const completion = await tab(cli);
22
22
23
23
// Get the dev command completion handler
24
24
const devCommandCompletion = completion.commands.get('dev');
25
25
26
26
// Get and configure the port option completion handler
27
-
const portOptionCompletion = devCommandCompletion.options.get('--port');
28
-
portOptionCompletion.handler = async () => {
29
-
return [
30
-
{ value: '3000', description: 'Development port' },
31
-
{ value: '8080', description: 'Production port' },
32
-
];
27
+
const portOptionCompletion = devCommandCompletion.options.get('port');
28
+
portOptionCompletion.handler = (complete) => {
29
+
complete('3000', 'Development port');
30
+
complete('8080', 'Production port');
33
31
};
34
32
35
33
// Configure build mode completions
36
34
const buildCommandCompletion = completion.commands.get('build');
37
-
const modeOptionCompletion = buildCommandCompletion.options.get('--mode');
38
-
modeOptionCompletion.handler = async () => {
39
-
return [
40
-
{ value: 'development', description: 'Development build' },
41
-
{ value: 'production', description: 'Production build' },
42
-
];
35
+
const modeOptionCompletion = buildCommandCompletion.options.get('mode');
36
+
modeOptionCompletion.handler = (complete) => {
37
+
complete('development', 'Development build');
38
+
complete('production', 'Production build');
43
39
};
44
40
45
41
cli.parse();
···
100
96
// Configure completions
101
97
const devCommandCompletion = completion.commands.get('dev');
102
98
if (devCommandCompletion) {
103
-
const portOptionCompletion = devCommandCompletion.options.get('--port');
99
+
const portOptionCompletion = devCommandCompletion.options.get('port');
104
100
if (portOptionCompletion) {
105
-
portOptionCompletion.handler = async () => {
106
-
return [
107
-
{ value: '3000', description: 'Development port' },
108
-
{ value: '8080', description: 'Production port' },
109
-
];
101
+
portOptionCompletion.handler = (complete) => {
102
+
complete('3000', 'Development port');
103
+
complete('8080', 'Production port');
110
104
};
111
105
}
112
106
}
···
154
148
// Configure completions
155
149
const devCommandCompletion = completion.commands.get('dev');
156
150
if (devCommandCompletion) {
157
-
const portOptionCompletion = devCommandCompletion.options.get('--port');
151
+
const portOptionCompletion = devCommandCompletion.options.get('port');
158
152
if (portOptionCompletion) {
159
-
portOptionCompletion.handler = async () => {
160
-
return [
161
-
{ value: '3000', description: 'Development port' },
162
-
{ value: '8080', description: 'Production port' },
163
-
];
153
+
portOptionCompletion.handler = (complete) => {
154
+
complete('3000', 'Development port');
155
+
complete('8080', 'Production port');
164
156
};
165
157
}
166
158
}
+33
-33
src/content/docs/tab/guides/best-practices.mdx
+33
-33
src/content/docs/tab/guides/best-practices.mdx
···
13
13
14
14
```ts
15
15
// Good
16
-
devCmd.option('--port', 'Port number', function(complete) {
16
+
devCmd.option('port', 'Port number', function(complete) {
17
17
complete('3000', 'Development port (default)');
18
18
complete('8080', 'Production port');
19
19
complete('9000', 'Alternative port');
20
20
}, 'p');
21
21
22
22
// Avoid
23
-
devCmd.option('--port', 'Port number', function(complete) {
23
+
devCmd.option('port', 'Port number', function(complete) {
24
24
complete('3000', '');
25
25
complete('8080', '');
26
26
}, 'p');
···
31
31
Make your completions responsive to what the user is typing:
32
32
33
33
```ts
34
-
devCmd.option('--mode', 'Build mode', function(complete) {
34
+
devCmd.option('mode', 'Build mode', function(complete) {
35
35
// If user is typing 'dev', suggest development
36
36
if (this.toComplete?.startsWith('dev')) {
37
37
complete('development', 'Development mode');
···
56
56
Always handle errors in your completion handlers to prevent crashes:
57
57
58
58
```ts
59
-
devCmd.option('--config', 'Config file', async function(complete) {
59
+
devCmd.option('config', 'Config file', async function(complete) {
60
60
try {
61
61
const files = await fs.readdir('.');
62
62
const configFiles = files.filter(f => f.includes('config'));
···
136
136
137
137
```ts
138
138
// Good - short aliases for common options
139
-
devCmd.option('--port', 'Port number', handler, 'p');
140
-
devCmd.option('--host', 'Host address', handler, 'h');
141
-
devCmd.option('--verbose', 'Enable verbose logging', 'v');
139
+
devCmd.option('port', 'Port number', handler, 'p');
140
+
devCmd.option('host', 'Host address', handler, 'h');
141
+
devCmd.option('verbose', 'Enable verbose logging', 'v');
142
142
143
143
// Avoid - too many short aliases
144
-
devCmd.option('--config', 'Config file', handler, 'c');
145
-
devCmd.option('--mode', 'Build mode', handler, 'm');
146
-
devCmd.option('--output', 'Output directory', handler, 'o');
147
-
devCmd.option('--source', 'Source directory', handler, 's');
144
+
devCmd.option('config', 'Config file', handler, 'c');
145
+
devCmd.option('mode', 'Build mode', handler, 'm');
146
+
devCmd.option('output', 'Output directory', handler, 'o');
147
+
devCmd.option('source', 'Source directory', handler, 's');
148
148
```
149
149
150
150
## Option Design Best Practices
···
155
155
156
156
```ts
157
157
// Good - boolean flags for simple options
158
-
devCmd.option('--verbose', 'Enable verbose logging', 'v');
159
-
devCmd.option('--quiet', 'Suppress output', 'q');
160
-
devCmd.option('--watch', 'Watch for changes', 'w');
158
+
devCmd.option('verbose', 'Enable verbose logging', 'v');
159
+
devCmd.option('quiet', 'Suppress output', 'q');
160
+
devCmd.option('watch', 'Watch for changes', 'w');
161
161
162
162
// Good - value options for complex data
163
-
devCmd.option('--port', 'Port number', function(complete) {
163
+
devCmd.option('port', 'Port number', function(complete) {
164
164
complete('3000', 'Development port');
165
165
complete('8080', 'Production port');
166
166
}, 'p');
···
171
171
When possible, provide sensible default values in your suggestions:
172
172
173
173
```ts
174
-
devCmd.option('--port', 'Port number', function(complete) {
174
+
devCmd.option('port', 'Port number', function(complete) {
175
175
complete('3000', 'Development port (default)');
176
176
complete('8080', 'Production port');
177
177
complete('9000', 'Alternative port');
···
184
184
185
185
```ts
186
186
// Good - descriptive names
187
-
devCmd.option('--output-dir', 'Output directory', handler);
188
-
devCmd.option('--source-map', 'Generate source maps', handler);
187
+
devCmd.option('output-dir', 'Output directory', handler);
188
+
devCmd.option('source-map', 'Generate source maps', handler);
189
189
190
190
// Avoid - ambiguous names
191
-
devCmd.option('--output', 'Output directory', handler);
192
-
devCmd.option('--map', 'Generate source maps', handler);
191
+
devCmd.option('output', 'Output directory', handler);
192
+
devCmd.option('map', 'Generate source maps', handler);
193
193
```
194
194
195
195
## Argument Design Best Practices
···
268
268
```ts
269
269
// Example: Comprehensive pnpm completions
270
270
const addCmd = t.command('add', 'Install packages');
271
-
addCmd.option('--save-dev', 'Save to devDependencies', 'D');
272
-
addCmd.option('--save-optional', 'Save to optionalDependencies', 'O');
273
-
addCmd.option('--global', 'Install globally', 'g');
271
+
addCmd.option('save-dev', 'Save to devDependencies', 'D');
272
+
addCmd.option('save-optional', 'Save to optionalDependencies', 'O');
273
+
addCmd.option('global', 'Install globally', 'g');
274
274
275
275
const runCmd = t.command('run', 'Run scripts');
276
276
runCmd.argument('script', async function(complete) {
···
323
323
Limit the number of completions to maintain performance:
324
324
325
325
```ts
326
-
devCmd.option('--config', 'Config file', async function(complete) {
326
+
devCmd.option('config', 'Config file', async function(complete) {
327
327
try {
328
328
const files = await fs.readdir('.');
329
329
const configFiles = files.filter(f => f.includes('config'));
···
341
341
342
342
```ts
343
343
// Good - sync operations for simple completions
344
-
devCmd.option('--mode', 'Build mode', function(complete) {
344
+
devCmd.option('mode', 'Build mode', function(complete) {
345
345
complete('development', 'Development mode');
346
346
complete('production', 'Production mode');
347
347
complete('staging', 'Staging mode');
348
348
});
349
349
350
350
// Good - async operations for dynamic data
351
-
devCmd.option('--config', 'Config file', async function(complete) {
351
+
devCmd.option('config', 'Config file', async function(complete) {
352
352
const files = await fs.readdir('.');
353
353
const configFiles = files.filter(f => f.includes('config'));
354
354
configFiles.forEach(file => complete(file, `Config file: ${file}`));
···
362
362
Start with common options and provide more specific ones as users type:
363
363
364
364
```ts
365
-
devCmd.option('--mode', 'Build mode', function(complete) {
365
+
devCmd.option('mode', 'Build mode', function(complete) {
366
366
if (this.toComplete?.startsWith('dev')) {
367
367
complete('development', 'Development mode');
368
368
return;
···
387
387
388
388
```ts
389
389
// Good - consistent formatting
390
-
devCmd.option('--port', 'Port number', function(complete) {
390
+
devCmd.option('port', 'Port number', function(complete) {
391
391
complete('3000', 'Development port (default)');
392
392
complete('8080', 'Production port');
393
393
complete('9000', 'Alternative port');
394
394
}, 'p');
395
395
396
396
// Avoid - inconsistent formatting
397
-
devCmd.option('--port', 'Port number', function(complete) {
397
+
devCmd.option('port', 'Port number', function(complete) {
398
398
complete('3000', 'dev port');
399
399
complete('8080', 'Production port');
400
400
complete('9000', 'alt port');
···
406
406
Include default values in descriptions when helpful:
407
407
408
408
```ts
409
-
devCmd.option('--port', 'Port number', function(complete) {
409
+
devCmd.option('port', 'Port number', function(complete) {
410
410
complete('3000', 'Development port (default)');
411
411
complete('8080', 'Production port');
412
412
}, 'p');
413
413
414
-
devCmd.option('--host', 'Host address', function(complete) {
414
+
devCmd.option('host', 'Host address', function(complete) {
415
415
complete('localhost', 'Localhost (default)');
416
416
complete('0.0.0.0', 'All interfaces');
417
417
}, 'h');
···
443
443
444
444
```ts
445
445
// Test with missing files
446
-
devCmd.option('--config', 'Config file', async function(complete) {
446
+
devCmd.option('config', 'Config file', async function(complete) {
447
447
try {
448
448
const files = await fs.readdir('.');
449
449
const configFiles = files.filter(f => f.includes('config'));
···
462
462
463
463
```ts
464
464
// Add timing for performance monitoring
465
-
devCmd.option('--config', 'Config file', async function(complete) {
465
+
devCmd.option('config', 'Config file', async function(complete) {
466
466
const start = Date.now();
467
467
try {
468
468
const files = await fs.readdir('.');
+32
-42
src/content/docs/tab/guides/examples.mdx
+32
-42
src/content/docs/tab/guides/examples.mdx
···
16
16
const t = new RootCommand();
17
17
18
18
// Add global options
19
-
t.option('--config', 'Use specified config file', function(complete) {
19
+
t.option('config', 'Use specified config file', function(complete) {
20
20
complete('vite.config.ts', 'Vite config file');
21
21
complete('vite.config.js', 'Vite config file');
22
22
}, 'c');
23
23
24
-
t.option('--mode', 'Set env mode', function(complete) {
24
+
t.option('mode', 'Set env mode', function(complete) {
25
25
complete('development', 'Development mode');
26
26
complete('production', 'Production mode');
27
27
}, 'm');
···
34
34
35
35
// Add commands with completions
36
36
const devCmd = t.command('dev', 'Start development server');
37
-
devCmd.option('--port', 'Port number', function(complete) {
37
+
devCmd.option('port', 'Port number', function(complete) {
38
38
complete('3000', 'Development port');
39
39
complete('8080', 'Production port');
40
40
}, 'p');
41
41
42
-
devCmd.option('--host', 'Host address', function(complete) {
42
+
devCmd.option('host', 'Host address', function(complete) {
43
43
complete('localhost', 'Local development');
44
44
complete('0.0.0.0', 'All interfaces');
45
45
}, 'h');
46
46
47
-
devCmd.option('--verbose', 'Enable verbose logging', 'v');
47
+
devCmd.option('verbose', 'Enable verbose logging', 'v');
48
48
49
49
// Add build command
50
50
const buildCmd = t.command('build', 'Build for production');
51
-
buildCmd.option('--mode', 'Build mode', function(complete) {
51
+
buildCmd.option('mode', 'Build mode', function(complete) {
52
52
complete('development', 'Development build');
53
53
complete('production', 'Production build');
54
54
});
55
55
56
-
buildCmd.option('--out-dir', 'Output directory', function(complete) {
56
+
buildCmd.option('out-dir', 'Output directory', function(complete) {
57
57
complete('dist/', 'Distribution directory');
58
58
complete('build/', 'Build directory');
59
59
});
···
122
122
});
123
123
124
124
// Initialize Tab completion
125
-
const completion = tab(cli);
125
+
const completion = await tab(cli);
126
126
127
127
// Configure custom completions
128
128
const devCommandCompletion = completion.commands.get('dev');
129
129
if (devCommandCompletion) {
130
-
const portOptionCompletion = devCommandCompletion.options.get('--port');
130
+
const portOptionCompletion = devCommandCompletion.options.get('port');
131
131
if (portOptionCompletion) {
132
-
portOptionCompletion.handler = async () => {
133
-
return [
134
-
{ value: '3000', description: 'Development port' },
135
-
{ value: '8080', description: 'Production port' },
136
-
];
132
+
portOptionCompletion.handler = (complete) => {
133
+
complete('3000', 'Development port');
134
+
complete('8080', 'Production port');
137
135
};
138
136
}
139
137
140
-
const configOptionCompletion = devCommandCompletion.options.get('--config');
138
+
const configOptionCompletion = devCommandCompletion.options.get('config');
141
139
if (configOptionCompletion) {
142
-
configOptionCompletion.handler = async () => {
143
-
return [
144
-
{ value: 'vite.config.ts', description: 'Vite config file' },
145
-
{ value: 'vite.config.js', description: 'Vite config file' },
146
-
];
140
+
configOptionCompletion.handler = (complete) => {
141
+
complete('vite.config.ts', 'Vite config file');
142
+
complete('vite.config.js', 'Vite config file');
147
143
};
148
144
}
149
145
}
150
146
151
147
const buildCommandCompletion = completion.commands.get('build');
152
148
if (buildCommandCompletion) {
153
-
const modeOptionCompletion = buildCommandCompletion.options.get('--mode');
149
+
const modeOptionCompletion = buildCommandCompletion.options.get('mode');
154
150
if (modeOptionCompletion) {
155
-
modeOptionCompletion.handler = async () => {
156
-
return [
157
-
{ value: 'development', description: 'Development build' },
158
-
{ value: 'production', description: 'Production build' },
159
-
];
151
+
modeOptionCompletion.handler = (complete) => {
152
+
complete('development', 'Development build');
153
+
complete('production', 'Production build');
160
154
};
161
155
}
162
156
}
···
225
219
// Configure completions
226
220
const devCommandCompletion = completion.commands.get('dev');
227
221
if (devCommandCompletion) {
228
-
const portOptionCompletion = devCommandCompletion.options.get('--port');
222
+
const portOptionCompletion = devCommandCompletion.options.get('port');
229
223
if (portOptionCompletion) {
230
-
portOptionCompletion.handler = async () => {
231
-
return [
232
-
{ value: '3000', description: 'Development port' },
233
-
{ value: '8080', description: 'Production port' },
234
-
];
224
+
portOptionCompletion.handler = (complete) => {
225
+
complete('3000', 'Development port');
226
+
complete('8080', 'Production port');
235
227
};
236
228
}
237
229
}
···
289
281
// Configure completions
290
282
const devCommandCompletion = completion.commands.get('dev');
291
283
if (devCommandCompletion) {
292
-
const portOptionCompletion = devCommandCompletion.options.get('--port');
284
+
const portOptionCompletion = devCommandCompletion.options.get('port');
293
285
if (portOptionCompletion) {
294
-
portOptionCompletion.handler = async () => {
295
-
return [
296
-
{ value: '3000', description: 'Development port' },
297
-
{ value: '8080', description: 'Production port' },
298
-
];
286
+
portOptionCompletion.handler = (complete) => {
287
+
complete('3000', 'Development port');
288
+
complete('8080', 'Production port');
299
289
};
300
290
}
301
291
}
···
316
306
const t = new RootCommand();
317
307
318
308
t.command('build', 'Build project')
319
-
.option('--config', 'Config file', async function(complete) {
309
+
.option('config', 'Config file', async function(complete) {
320
310
try {
321
311
const files = await readdir('.');
322
312
const configFiles = files.filter(f =>
···
339
329
const t = new RootCommand();
340
330
341
331
t.command('deploy', 'Deploy application')
342
-
.option('--env', 'Environment', function(complete) {
332
+
.option('env', 'Environment', function(complete) {
343
333
// Check if user is typing a specific environment
344
334
if (this.toComplete?.startsWith('prod')) {
345
335
complete('production', 'Production environment');
···
350
340
complete('staging', 'Staging environment');
351
341
complete('production', 'Production environment');
352
342
})
353
-
.option('--region', 'Region', function(complete) {
343
+
.option('region', 'Region', function(complete) {
354
344
// Provide region completions based on environment
355
345
const env = this.command?.options?.get('--env')?.value;
356
346
···
401
391
const t = new RootCommand();
402
392
403
393
t.command('workspace', 'Workspace commands')
404
-
.option('--filter', 'Filter workspaces', async function(complete) {
394
+
.option('filter', 'Filter workspaces', async function(complete) {
405
395
try {
406
396
const packageJson = JSON.parse(await readFile('package.json', 'utf8'));
407
397
const workspaces = packageJson.workspaces || [];
+1
-1
src/content/docs/tab/index.mdx
+1
-1
src/content/docs/tab/index.mdx
···
50
50
51
51
// Add commands with completions
52
52
t.command('dev', 'Start development server')
53
-
.option('--port', 'Port number', function(complete) {
53
+
.option('port', 'Port number', function(complete) {
54
54
complete('3000', 'Development port');
55
55
complete('8080', 'Production port');
56
56
}, 'p');