refactor(cli): make call tool-invocation only

Author: RhysSullivan

README.md

@@ -78,11 +78,9 @@ const issues = await tools.github.issues.list({
 });
 ```
 
-Run code via the CLI:
+Use tools via the CLI:
 
 ```bash
-executor call --file script.ts
-executor call 'return await tools.discover({ query: "send email" })'
 executor tools search "send email"
 executor call gmail send '{"to":"alice@example.com","subject":"Hi"}'
 executor call github issues create '{"owner":"octocat","repo":"Hello-World","title":"Hi"}'
@@ -106,14 +104,11 @@ executor daemon status              # show daemon status
 executor daemon stop                # stop daemon
 executor daemon restart             # restart daemon
 executor mcp                        # start MCP endpoint
-executor call --file script.ts      # execute a file
-executor call '<code>'              # execute inline code
-executor call --stdin               # execute from stdin
+executor call <path...> '{"k":"v"}' # invoke a tool by path segments
 executor resume --execution-id <id> # resume paused execution
 executor tools search "<query>"     # search tools by intent
 executor tools sources              # list configured sources + tool counts
 executor tools describe <path>      # show tool TypeScript/JSON schema
-executor call <path...> '{"k":"v"}' # invoke a tool by path segments
 ```
 
 ## Developing locally

apps/cli/src/main.ts

@@ -73,7 +73,6 @@ import {
   buildSearchToolsCode,
   extractExecutionId,
   extractExecutionResult,
-  isLikelyToolPathToken,
   parseJsonObjectInput,
 } from "./tooling";
 
@@ -529,46 +528,6 @@ const runStdioMcpSession = () =>
     );
   });
 
-// ---------------------------------------------------------------------------
-// Code resolution — positional arg > --file > stdin
-// ---------------------------------------------------------------------------
-
-const readCode = (input: {
-  code: Option.Option<string>;
-  file: Option.Option<string>;
-  stdin: boolean;
-}): Effect.Effect<string, Error, FileSystem.FileSystem> =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const code = Option.getOrUndefined(input.code);
-    if (code && code.trim().length > 0) return code;
-
-    const file = Option.getOrUndefined(input.file);
-    if (file && file.trim().length > 0) {
-      const contents = yield* fs.readFileString(file).pipe(
-        Effect.mapError((cause) => new Error(`Failed to read file: ${String(cause)}`)),
-      );
-      if (contents.trim().length > 0) return contents;
-    }
-
-    if (input.stdin || !process.stdin.isTTY) {
-      const chunks: string[] = [];
-      process.stdin.setEncoding("utf8");
-      const contents = yield* Effect.tryPromise({
-        try: async () => {
-          for await (const chunk of process.stdin) chunks.push(chunk as string);
-          return chunks.join("");
-        },
-        catch: (e) => new Error(`Failed to read stdin: ${e}`),
-      });
-      if (contents.trim().length > 0) return contents;
-    }
-
-    return yield* Effect.fail(
-      new Error("No code provided. Pass code as an argument, --file, or pipe to stdin."),
-    );
-  });
-
 const scope = Options.text("scope").pipe(
   Options.optional,
   Options.withDescription("Path to workspace directory containing executor.jsonc"),
@@ -610,67 +569,28 @@ const resolveToolInvocation = (input: {
 const callCommand = Command.make(
   "call",
   {
-    codeOrTool: Args.text({ name: "code-or-tool" }).pipe(Args.repeated),
-    file: Options.text("file").pipe(Options.optional),
-    stdin: Options.boolean("stdin").pipe(Options.withDefault(false)),
+    pathParts: Args.text({ name: "tool-path-segment" }).pipe(Args.repeated),
     baseUrl: Options.text("base-url").pipe(Options.withDefault(DEFAULT_BASE_URL)),
     scope,
   },
-  ({ codeOrTool, file, stdin, baseUrl, scope }) =>
+  ({ pathParts, baseUrl, scope }) =>
     Effect.gen(function* () {
       applyScope(scope);
-      const singleArg = codeOrTool.length === 1 ? codeOrTool[0] : undefined;
-      const singleArgLooksLikeToolPath =
-        singleArg !== undefined && singleArg.includes(".") && isLikelyToolPathToken(singleArg);
-      const isToolInvocation =
-        !stdin &&
-        Option.isNone(file) &&
-        (codeOrTool.length > 1 || singleArgLooksLikeToolPath);
-
-      if (isToolInvocation) {
-        const { path, args } = yield* resolveToolInvocation({
-          rawPathParts: codeOrTool,
-        });
-        const code = yield* Effect.try({
-          try: () => buildInvokeToolCode(path, args),
-          catch: (cause) =>
-            cause instanceof Error ? cause : new Error(`Invalid tool path: ${String(cause)}`),
-        });
-
-        const outcome = yield* executeCode({ baseUrl, code });
-        yield* printExecutionOutcome({ baseUrl, outcome });
-        return;
-      }
-
-      const inlineCode = singleArg !== undefined ? Option.some(singleArg) : Option.none<string>();
-      const resolvedCode = yield* readCode({ code: inlineCode, file, stdin });
-      const daemonUrl = yield* ensureDaemon(baseUrl);
-
-      const client = yield* makeApiClient(daemonUrl);
-      const result = yield* client.executions.execute({ payload: { code: resolvedCode } });
+      const { path, args } = yield* resolveToolInvocation({
+        rawPathParts: pathParts,
+      });
+      const code = yield* Effect.try({
+        try: () => buildInvokeToolCode(path, args),
+        catch: (cause) =>
+          cause instanceof Error ? cause : new Error(`Invalid tool path: ${String(cause)}`),
+      });
 
-      if (result.status === "completed") {
-        if (result.isError) {
-          console.error(result.text);
-          process.exit(1);
-        } else {
-          console.log(result.text);
-          process.exit(0);
-        }
-      } else {
-        console.log(result.text);
-        const executionId = (result.structured as Record<string, unknown> | undefined)?.executionId;
-        if (executionId) {
-          console.log(
-            `\nTo resume:\n  ${cliPrefix} resume --execution-id ${executionId} --action accept`,
-          );
-        }
-        process.exit(0);
-      }
+      const outcome = yield* executeCode({ baseUrl, code });
+      yield* printExecutionOutcome({ baseUrl, outcome });
     }),
 ).pipe(
   Command.withDescription(
-    "Execute JavaScript or invoke a tool path (e.g. `executor call github issues create '{\"title\":\"Hi\"}'`)",
+    "Invoke a tool path (e.g. `executor call github issues create '{\"title\":\"Hi\"}'`)",
   ),
 );
 

apps/cli/src/tooling.ts

@@ -16,14 +16,14 @@ export const buildToolPath = (parts: ReadonlyArray<string>): string => {
   if (segments.length === 0) {
     throw new Error("Tool path must include at least one segment");
   }
+  if (segments.some((segment) => !TOOL_PATH_TOKEN.test(segment))) {
+    throw new Error(
+      "Tool path segments must contain only letters, numbers, '.', '_' or '-'",
+    );
+  }
   return segments.join(".");
 };
 
-export const isLikelyToolPathToken = (raw: string): boolean => {
-  const value = raw.trim();
-  return value.length > 0 && TOOL_PATH_TOKEN.test(value);
-};
-
 const buildToolAccessExpression = (toolPath: string): string => {
   const segments = toToolPathSegments([toolPath]);
   if (segments.length === 0) {

tests/tools-cli.test.ts

@@ -8,7 +8,6 @@ import {
   buildSearchToolsCode,
   extractExecutionId,
   extractExecutionResult,
-  isLikelyToolPathToken,
   parseJsonObjectInput,
 } from "../apps/cli/src/tooling";
 
@@ -45,9 +44,8 @@ describe("CLI tooling helpers", () => {
     expect(buildToolPath(["github.issues", "create"])).toBe("github.issues.create");
   });
 
-  it("detects likely tool path tokens", () => {
-    expect(isLikelyToolPathToken("github.issues.create")).toBe(true);
-    expect(isLikelyToolPathToken("return await tools.search({})")).toBe(false);
+  it("rejects invalid tool-path segments", () => {
+    expect(() => buildToolPath(["github", "issues", "create now"])).toThrow();
   });
 
   it("builds search and sources code snippets", () => {