runspec-node 0.3.0 → 0.8.0

package/src/serve.ts

@@ -12,39 +12,43 @@ const ERR_PARSE = -32700;
 const ERR_METHOD_NOT_FOUND = -32601;
 const ERR_INVALID_PARAMS = -32602;
 
+const SHELL_EXTS = ['', '.sh', '.ksh', '.bash', '.zsh'];
+
 export function serve(): void {
   let configPath: string;
-  let format: 'pyproject' | 'runspec';
 
   try {
-    ({ configPath, format } = findConfig(process.cwd()));
+    ({ configPath } = findConfig(process.cwd()));
   } catch (e) {
     process.stderr.write(`runspec serve: ${(e as Error).message}\n`);
     process.exit(1);
   }
 
-  const raw = loadRaw(configPath, format);
+  const raw = loadRaw(configPath);
   const config = raw.config;
 
   const tools: Record<string, Record<string, unknown>> = {};
   const argSpecs: Record<string, Record<string, unknown>> = {};
+  const execSpecs: Record<string, { command: string | null }> = {};
+
+  const binDir = path.join(path.dirname(configPath), 'node_modules', '.bin');
 
   for (const [name, runnable] of Object.entries(raw.runnables)) {
     const inferred = inferScript(runnable, config.autonomyDefault);
     tools[name] = buildSchema(name, inferred, 'mcp');
     argSpecs[name] = inferred.args ?? {};
+    execSpecs[name] = { command: findScript(name, binDir) };
   }
 
   const serverName = serverNameFromConfig(config as unknown as Record<string, unknown>);
-  const binDir = path.join(path.dirname(configPath), 'node_modules', '.bin');
 
-  mcpLoop(tools, argSpecs, binDir, serverName);
+  mcpLoop(tools, argSpecs, execSpecs, serverName);
 }
 
 function mcpLoop(
   tools: Record<string, Record<string, unknown>>,
   argSpecs: Record<string, Record<string, unknown>>,
-  binDir: string,
+  execSpecs: Record<string, { command: string | null }>,
   serverName: string,
 ): void {
   const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
@@ -61,7 +65,7 @@ function mcpLoop(
       return;
     }
 
-    const response = dispatch(request, tools, argSpecs, binDir, serverName);
+    const response = dispatch(request, tools, argSpecs, execSpecs, serverName);
     if (response !== null) writeMsg(response);
   });
 }
@@ -70,7 +74,7 @@ function dispatch(
   request: Record<string, unknown>,
   tools: Record<string, Record<string, unknown>>,
   argSpecs: Record<string, Record<string, unknown>>,
-  binDir: string,
+  execSpecs: Record<string, { command: string | null }>,
   serverName: string,
 ): Record<string, unknown> | null {
   const method = (request['method'] as string) ?? '';
@@ -81,14 +85,14 @@ function dispatch(
   if (method === 'initialize') return handleInitialize(reqId, serverName);
   if (method === 'tools/list') return handleToolsList(reqId, tools);
   if (method === 'tools/call') {
-    return handleToolsCall(reqId, (request['params'] ?? {}) as Record<string, unknown>, tools, argSpecs, binDir);
+    return handleToolsCall(reqId, (request['params'] ?? {}) as Record<string, unknown>, tools, argSpecs, execSpecs);
   }
 
   return { jsonrpc: '2.0', id: reqId, error: { code: ERR_METHOD_NOT_FOUND, message: `Method not found: ${method}` } };
 }
 
 function handleInitialize(reqId: unknown, serverName: string): Record<string, unknown> {
-  const version = '0.3.0';
+  const version = '0.6.0';
   return {
     jsonrpc: '2.0',
     id: reqId,
@@ -109,7 +113,7 @@ function handleToolsCall(
   params: Record<string, unknown>,
   tools: Record<string, Record<string, unknown>>,
   argSpecs: Record<string, Record<string, unknown>>,
-  binDir: string,
+  execSpecs: Record<string, { command: string | null }>,
 ): Record<string, unknown> {
   const name = (params['name'] as string) ?? '';
   const args = (params['arguments'] as Record<string, unknown>) ?? {};
@@ -118,20 +122,22 @@ function handleToolsCall(
     return { jsonrpc: '2.0', id: reqId, error: { code: ERR_INVALID_PARAMS, message: `Unknown tool: ${name}` } };
   }
 
-  const cmd = findScript(name, binDir);
+  const cmd = execSpecs[name]?.command ?? null;
   if (!cmd) {
     return {
       jsonrpc: '2.0',
       id: reqId,
       result: {
-        content: [{ type: 'text', text: `Script not found in ${binDir}: ${name}` }],
+        content: [{ type: 'text', text: `Script '${name}' not found. Place it alongside runspec.toml or in a bin/ subdirectory.` }],
         isError: true,
       },
     };
   }
 
-  const argv = argsToArgv(args, argSpecs[name] ?? {});
-  const env = { ...process.env, RUNSPEC_AGENT: '1' };
+  const toolArgSpecs = argSpecs[name] ?? {};
+  const argv = argsToArgv(args, toolArgSpecs);
+  const runspecEnv = argsToRunspecEnv(args, toolArgSpecs);
+  const env = { ...process.env, RUNSPEC_AGENT: '1', ...runspecEnv };
 
   const result = spawnSync(cmd, argv, { encoding: 'utf-8', env });
 
@@ -159,7 +165,7 @@ function argsToArgv(args: Record<string, unknown>, argSpecs: Record<string, unkn
 
   for (const [argName, spec] of Object.entries(argSpecs)) {
     const s = spec as Record<string, unknown>;
-    let value = args[argName] ?? args[argName.replace(/-/g, '_')];
+    const value = args[argName] ?? args[argName.replace(/-/g, '_')];
     if (value === null || value === undefined) continue;
 
     const flag = `--${argName}`;
@@ -177,11 +183,46 @@ function argsToArgv(args: Record<string, unknown>, argSpecs: Record<string, unkn
   return argv;
 }
 
+function argsToRunspecEnv(args: Record<string, unknown>, argSpecs: Record<string, unknown>): Record<string, string> {
+  const env: Record<string, string> = {};
+
+  for (const [argName, spec] of Object.entries(argSpecs)) {
+    const s = spec as Record<string, unknown>;
+    let value = args[argName] ?? args[argName.replace(/-/g, '_')];
+    if (value === null || value === undefined) value = s['default'];
+    if (value === null || value === undefined) continue;
+
+    const envKey = 'RUNSPEC_' + argName.toUpperCase().replace(/-/g, '_').replace(/\./g, '_');
+    const argType = (s['type'] as string) ?? 'str';
+
+    if (argType === 'flag' || argType === 'bool') {
+      env[envKey] = value ? '1' : '0';
+    } else if (s['multiple'] && Array.isArray(value)) {
+      env[envKey] = (value as unknown[]).map(String).join('\n');
+    } else {
+      env[envKey] = String(value);
+    }
+  }
+
+  return env;
+}
+
 function findScript(name: string, binDir: string): string | null {
-  const candidate = path.join(binDir, name);
-  if (fs.existsSync(candidate)) return candidate;
-  const candidateExe = path.join(binDir, name + '.exe');
-  if (fs.existsSync(candidateExe)) return candidateExe;
+  // 1. node_modules/.bin (Node entry points; also .exe on Windows)
+  for (const ext of [...SHELL_EXTS, '.exe']) {
+    const candidate = path.join(binDir, name + ext);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+
+  // 2. cwd/ and cwd/bin/
+  const cwd = process.cwd();
+  for (const dir of [cwd, path.join(cwd, 'bin')]) {
+    for (const ext of SHELL_EXTS) {
+      const candidate = path.join(dir, name + ext);
+      if (fs.existsSync(candidate)) return candidate;
+    }
+  }
+
   return null;
 }
 

package/src/types.ts

@@ -94,3 +94,4 @@ registerType('bool', coerceBool);
 registerType('flag', coerceFlag);
 registerType('path', coercePath);
 registerType('choice', coerceChoice);
+registerType('rest', (v) => (Array.isArray(v) ? v : []));

package/tests/test_cli_init.test.ts

@@ -0,0 +1,210 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { execFileSync } from 'child_process';
+
+const CLI = path.resolve(__dirname, '../bin/runspec.js');
+
+function tmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'runspec-init-test-'));
+}
+
+function runCLI(dir: string, cliArgs: string[]): { stdout: string; stderr: string } {
+  try {
+    const stdout = execFileSync('node', [CLI, ...cliArgs], { cwd: dir, encoding: 'utf-8' });
+    return { stdout, stderr: '' };
+  } catch (e: any) {
+    return { stdout: e.stdout ?? '', stderr: e.stderr ?? '' };
+  }
+}
+
+function runInit(dir: string, extraArgs: string[] = []): { stdout: string; stderr: string } {
+  return runCLI(dir, ['init', ...extraArgs]);
+}
+
+// ── init (basic) ──────────────────────────────────────────────────────────────
+
+test('creates runspec.toml and .ts stub by default', () => {
+  const dir = tmpDir();
+  const { stdout } = runInit(dir, ['--name', 'greet']);
+  expect(fs.existsSync(path.join(dir, 'runspec.toml'))).toBe(true);
+  expect(fs.existsSync(path.join(dir, 'greet.ts'))).toBe(true);
+  expect(stdout).toContain('Created runspec.toml');
+  expect(stdout).toContain('Created greet.ts');
+});
+
+test('runspec.toml contains the runnable name', () => {
+  const dir = tmpDir();
+  runInit(dir, ['--name', 'deploy']);
+  const toml = fs.readFileSync(path.join(dir, 'runspec.toml'), 'utf-8');
+  expect(toml).toContain('[deploy]');
+});
+
+test('typescript stub imports parse from runspec-node', () => {
+  const dir = tmpDir();
+  runInit(dir, ['--name', 'greet']);
+  const ts = fs.readFileSync(path.join(dir, 'greet.ts'), 'utf-8');
+  expect(ts).toContain("import { parse } from 'runspec-node'");
+  expect(ts).toContain('function main()');
+  expect(ts).toContain('main();');
+});
+
+test('--lang javascript generates .js stub', () => {
+  const dir = tmpDir();
+  runInit(dir, ['--name', 'greet', '--lang', 'javascript']);
+  expect(fs.existsSync(path.join(dir, 'greet.js'))).toBe(true);
+  const js = fs.readFileSync(path.join(dir, 'greet.js'), 'utf-8');
+  expect(js).toContain("require('runspec-node')");
+  expect(js).toContain('main();');
+});
+
+test('--lang python generates .py stub', () => {
+  const dir = tmpDir();
+  runInit(dir, ['--name', 'greet', '--lang', 'python']);
+  expect(fs.existsSync(path.join(dir, 'greet.py'))).toBe(true);
+  const py = fs.readFileSync(path.join(dir, 'greet.py'), 'utf-8');
+  expect(py).toContain('from runspec import parse');
+  expect(py).toContain('if __name__ == "__main__"');
+});
+
+test('does not overwrite existing stub', () => {
+  const dir = tmpDir();
+  const stubPath = path.join(dir, 'greet.ts');
+  fs.writeFileSync(stubPath, '// existing\n', 'utf-8');
+  const { stdout } = runInit(dir, ['--name', 'greet']);
+  expect(fs.readFileSync(stubPath, 'utf-8')).toBe('// existing\n');
+  expect(stdout).toContain('already exists — skipped');
+});
+
+test('fails if runspec.toml already exists', () => {
+  const dir = tmpDir();
+  fs.writeFileSync(path.join(dir, 'runspec.toml'), '[greet]\n', 'utf-8');
+  const { stdout } = runInit(dir, ['--name', 'greet']);
+  expect(stdout).toContain('already exists');
+  expect(fs.existsSync(path.join(dir, 'greet.ts'))).toBe(false);
+});
+
+test('unknown --lang exits with error', () => {
+  const dir = tmpDir();
+  const { stdout } = runInit(dir, ['--name', 'greet', '--lang', 'ruby']);
+  expect(stdout).toContain('Unknown --lang');
+});
+
+// ── init --example ────────────────────────────────────────────────────────────
+
+test('--example creates runspec.toml with clean and scan', () => {
+  const dir = tmpDir();
+  runInit(dir, ['--example']);
+  const toml = fs.readFileSync(path.join(dir, 'runspec.toml'), 'utf-8');
+  expect(toml).toContain('[clean]');
+  expect(toml).toContain('[scan]');
+});
+
+test('--example creates clean.ts and scan.ts by default', () => {
+  const dir = tmpDir();
+  runInit(dir, ['--example']);
+  expect(fs.existsSync(path.join(dir, 'clean.ts'))).toBe(true);
+  expect(fs.existsSync(path.join(dir, 'scan.ts'))).toBe(true);
+});
+
+test('--example clean stub uses __runspec_agent__ check', () => {
+  const dir = tmpDir();
+  runInit(dir, ['--example']);
+  const ts = fs.readFileSync(path.join(dir, 'clean.ts'), 'utf-8');
+  expect(ts).toContain('__runspec_agent__');
+  expect(ts).toContain('delete');
+});
+
+test('--example scan stub always outputs JSON', () => {
+  const dir = tmpDir();
+  runInit(dir, ['--example']);
+  const ts = fs.readFileSync(path.join(dir, 'scan.ts'), 'utf-8');
+  expect(ts).toContain('JSON.stringify');
+  expect(ts).not.toContain('format');
+});
+
+test('--example scan toml has no format or delete arg', () => {
+  const dir = tmpDir();
+  runInit(dir, ['--example']);
+  const toml = fs.readFileSync(path.join(dir, 'runspec.toml'), 'utf-8');
+  const scanArgsSection = toml.split('[scan.args]')[1] ?? '';
+  expect(scanArgsSection).not.toContain('format');
+  expect(scanArgsSection).not.toContain('delete');
+});
+
+test('--example scan toml declares output = json', () => {
+  const dir = tmpDir();
+  runInit(dir, ['--example']);
+  const toml = fs.readFileSync(path.join(dir, 'runspec.toml'), 'utf-8');
+  expect(toml).toContain('output      = "json"');
+});
+
+test('--example shows demo prep commands', () => {
+  const dir = tmpDir();
+  const { stdout } = runInit(dir, ['--example']);
+  expect(stdout).toContain('touch -t 202401010000 report.tmp cache.tmp session.tmp');
+  expect(stdout).toContain('scan');
+  expect(stdout).toContain('clean');
+});
+
+test('--example with --name warns name is ignored', () => {
+  const dir = tmpDir();
+  const { stdout } = runInit(dir, ['--example', '--name', 'myapp']);
+  expect(stdout).toContain('--name is ignored');
+});
+
+test('--example --lang javascript creates clean.js and scan.js', () => {
+  const dir = tmpDir();
+  runInit(dir, ['--example', '--lang', 'javascript']);
+  expect(fs.existsSync(path.join(dir, 'clean.js'))).toBe(true);
+  expect(fs.existsSync(path.join(dir, 'scan.js'))).toBe(true);
+});
+
+// ── local command ─────────────────────────────────────────────────────────────
+
+test('local command is recognized', () => {
+  const dir = tmpDir();
+  const { stdout } = runCLI(dir, ['local']);
+  expect(stdout).not.toContain('Unknown command');
+});
+
+test('discover command is no longer available', () => {
+  const dir = tmpDir();
+  const { stdout } = runCLI(dir, ['discover']);
+  expect(stdout).toContain('Unknown command');
+});
+
+test('check command is no longer available', () => {
+  const dir = tmpDir();
+  const { stdout } = runCLI(dir, ['check']);
+  expect(stdout).toContain('Unknown command');
+});
+
+test('emit command is no longer available', () => {
+  const dir = tmpDir();
+  const { stdout } = runCLI(dir, ['emit']);
+  expect(stdout).toContain('Unknown command');
+});
+
+test('jump command requires a host name', () => {
+  const dir = tmpDir();
+  const { stderr } = runCLI(dir, ['jump']);
+  expect(stderr).toContain('jump host name is required');
+});
+
+// ── help ──────────────────────────────────────────────────────────────────────
+
+test('top-level help mentions local and jump', () => {
+  const dir = tmpDir();
+  const { stdout } = runCLI(dir, ['--help']);
+  expect(stdout).toContain('local');
+  expect(stdout).toContain('jump');
+  expect(stdout).not.toContain('discover');
+});
+
+test('local --help shows focused help', () => {
+  const dir = tmpDir();
+  const { stdout } = runCLI(dir, ['local', '--help']);
+  expect(stdout).toContain('--format');
+  expect(stdout).toContain('--script');
+});

package/tests/test_integration.test.ts

@@ -11,26 +11,26 @@ const COMPLEX = path.join(FIXTURES, 'complex.toml');
 
 describe('simple.toml', () => {
   test('loads config section', () => {
-    const raw = loadRaw(SIMPLE, 'runspec');
+    const raw = loadRaw(SIMPLE);
     expect(raw.config.autonomyDefault).toBe('confirm');
   });
 
   test('greet runnable present', () => {
-    const raw = loadRaw(SIMPLE, 'runspec');
+    const raw = loadRaw(SIMPLE);
     expect(raw.runnables['greet']).toBeDefined();
     expect(raw.runnables['greet'].description).toBe('Greet someone from the command line');
     expect(raw.runnables['greet'].autonomy).toBe('autonomous');
   });
 
   test('greet args: name is str and required', () => {
-    const raw = loadRaw(SIMPLE, 'runspec');
+    const raw = loadRaw(SIMPLE);
     const inferred = inferScript(raw.runnables['greet'], raw.config.autonomyDefault);
     expect(inferred.args['name'].type).toBe('str');
     expect(inferred.args['name'].required).toBe(true);
   });
 
   test('greet args: loud inferred as flag', () => {
-    const raw = loadRaw(SIMPLE, 'runspec');
+    const raw = loadRaw(SIMPLE);
     const inferred = inferScript(raw.runnables['greet'], raw.config.autonomyDefault);
     expect(inferred.args['loud'].type).toBe('flag');
     expect(inferred.args['loud'].required).toBe(false);
@@ -38,7 +38,7 @@ describe('simple.toml', () => {
   });
 
   test('greet args: times inferred as int', () => {
-    const raw = loadRaw(SIMPLE, 'runspec');
+    const raw = loadRaw(SIMPLE);
     const inferred = inferScript(raw.runnables['greet'], raw.config.autonomyDefault);
     expect(inferred.args['times'].type).toBe('int');
     expect(inferred.args['times'].default).toBe(1);
@@ -49,27 +49,27 @@ describe('simple.toml', () => {
 
 describe('complex.toml', () => {
   test('loads config section', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     expect(raw.config.autonomyDefault).toBe('confirm');
     expect(raw.config.lang).toBe('python');
     expect(raw.config.version).toBe('1');
   });
 
   test('pipeline runnable present', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     expect(raw.runnables['pipeline']).toBeDefined();
     expect(raw.runnables['pipeline'].description).toBe('Process and validate data pipeline files');
   });
 
   test('pipeline has run and validate subcommands', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const cmds = raw.runnables['pipeline'].commands;
     expect(cmds['run']).toBeDefined();
     expect(cmds['validate']).toBeDefined();
   });
 
   test('run subcommand: input is path and required', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const run = inferred.commands['run'];
     expect(run.args['input'].type).toBe('path');
@@ -77,7 +77,7 @@ describe('complex.toml', () => {
   });
 
   test('run subcommand: format is choice with default', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const run = inferred.commands['run'];
     expect(run.args['format'].type).toBe('choice');
@@ -87,7 +87,7 @@ describe('complex.toml', () => {
   });
 
   test('run subcommand: workers inferred as int with range', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const run = inferred.commands['run'];
     expect(run.args['workers'].type).toBe('int');
@@ -96,7 +96,7 @@ describe('complex.toml', () => {
   });
 
   test('run subcommand: dry-run inferred as flag', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const run = inferred.commands['run'];
     expect(run.args['dry-run'].type).toBe('flag');
@@ -104,7 +104,7 @@ describe('complex.toml', () => {
   });
 
   test('run subcommand: tag is multiple', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const run = inferred.commands['run'];
     expect(run.args['tag'].multiple).toBe(true);
@@ -112,7 +112,7 @@ describe('complex.toml', () => {
   });
 
   test('run subcommand: fields has delimiter', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const run = inferred.commands['run'];
     expect(run.args['fields'].delimiter).toBe(',');
@@ -120,7 +120,7 @@ describe('complex.toml', () => {
   });
 
   test('run subcommand: api-key has env and autonomy', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const run = inferred.commands['run'];
     expect(run.args['api-key'].env).toBe('PIPELINE_API_KEY');
@@ -128,21 +128,21 @@ describe('complex.toml', () => {
   });
 
   test('run subcommand: verbose has short flag', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const run = inferred.commands['run'];
     expect(run.args['verbose'].short).toBe('-v');
   });
 
   test('run subcommand: threads has deprecated field', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const run = inferred.commands['run'];
     expect(run.args['threads'].deprecated).toBe('use --workers instead');
   });
 
   test('run subcommand: groups defined', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const run = inferred.commands['run'];
     expect(run.groups['input-format']).toBeDefined();
@@ -152,21 +152,21 @@ describe('complex.toml', () => {
   });
 
   test('validate subcommand: is autonomous', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const validate = inferred.commands['validate'];
     expect(validate.autonomy).toBe('autonomous');
   });
 
   test('validate subcommand: format is choice', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const validate = inferred.commands['validate'];
     expect(validate.args['format'].type).toBe('choice');
   });
 
   test('run subcommand: autonomy-reason preserved', () => {
-    const raw = loadRaw(COMPLEX, 'runspec');
+    const raw = loadRaw(COMPLEX);
     const inferred = inferScript(raw.runnables['pipeline'], raw.config.autonomyDefault);
     const run = inferred.commands['run'];
     expect(run.autonomyReason).toBe('Writes output files and may call external APIs');

package/tests/test_loader.test.ts

@@ -25,7 +25,7 @@ autonomy = "autonomous"
 name = {type = "str"}
 loud = {default = false}
 `);
-  const raw = loadRaw(file, 'runspec');
+  const raw = loadRaw(file);
   expect(raw.runnables['greet']).toBeDefined();
   expect(raw.runnables['greet'].description).toBe('Greet someone');
   expect(raw.runnables['greet'].args['name'].type).toBe('str');
@@ -39,7 +39,7 @@ test('normalises hyphenated field names', () => {
 [deploy]
 autonomy-reason = "Irreversible"
 `);
-  const raw = loadRaw(file, 'runspec');
+  const raw = loadRaw(file);
   expect(raw.runnables['deploy'].autonomyReason).toBe('Irreversible');
 });
 
@@ -54,7 +54,7 @@ version = "1"
 [greet]
 description = "hi"
 `);
-  const raw = loadRaw(file, 'runspec');
+  const raw = loadRaw(file);
   expect(raw.config.autonomyDefault).toBe('autonomous');
   expect(raw.config.version).toBe('1');
 });
@@ -69,46 +69,11 @@ autonomy-default = "confirm"
 [greet]
 description = "hi"
 `);
-  const raw = loadRaw(file, 'runspec');
+  const raw = loadRaw(file);
   expect('config' in raw.runnables).toBe(false);
   expect('greet' in raw.runnables).toBe(true);
 });
 
-// ── pyproject.toml format ─────────────────────────────────────────────────────
-
-test('loads pyproject.toml format', () => {
-  const dir = tmpDir();
-  const file = path.join(dir, 'pyproject.toml');
-  fs.writeFileSync(file, `
-[project]
-name = "myproject"
-
-[tool.runspec.greet]
-description = "Greet"
-autonomy = "confirm"
-
-[tool.runspec.greet.args]
-name = {type = "str"}
-`);
-  const raw = loadRaw(file, 'pyproject');
-  expect(raw.runnables['greet']).toBeDefined();
-  expect(raw.runnables['greet'].args['name'].type).toBe('str');
-});
-
-test('reads entry points from pyproject.toml', () => {
-  const dir = tmpDir();
-  const file = path.join(dir, 'pyproject.toml');
-  fs.writeFileSync(file, `
-[project.scripts]
-greet = "myapp.greet:main"
-
-[tool.runspec.greet]
-description = "Greet"
-`);
-  const raw = loadRaw(file, 'pyproject');
-  expect(raw.entryPoints['greet']).toBe('myapp.greet:main');
-});
-
 // ── arg normalisation ─────────────────────────────────────────────────────────
 
 test('normalises bare value shorthand', () => {
@@ -122,7 +87,7 @@ description = "hi"
 loud = false
 times = 1
 `);
-  const raw = loadRaw(file, 'runspec');
+  const raw = loadRaw(file);
   expect(raw.runnables['greet'].args['loud'].default).toBe(false);
   expect(raw.runnables['greet'].args['times'].default).toBe(1);
 });
@@ -137,7 +102,7 @@ description = "hi"
 [greet.args]
 workers = {default = 4, range = [1, 32]}
 `);
-  const raw = loadRaw(file, 'runspec');
+  const raw = loadRaw(file);
   expect(raw.runnables['greet'].args['workers'].range).toEqual([1, 32]);
 });
 
@@ -152,7 +117,7 @@ description = "hi"
 exclusive = true
 args = ["json", "csv"]
 `);
-  const raw = loadRaw(file, 'runspec');
+  const raw = loadRaw(file);
   const group = raw.runnables['pipeline'].groups['formats'];
   expect(group.exclusive).toBe(true);
   expect(group.args).toEqual(['json', 'csv']);
@@ -164,6 +129,6 @@ test('autonomy-default falls back to confirm', () => {
   const dir = tmpDir();
   const file = path.join(dir, 'runspec.toml');
   fs.writeFileSync(file, `[greet]\ndescription = "hi"\n`);
-  const raw = loadRaw(file, 'runspec');
+  const raw = loadRaw(file);
   expect(raw.config.autonomyDefault).toBe('confirm');
 });