argsbarg 6.1.2 → 6.1.3

package/src/api/openapi.ts

@@ -1,117 +0,0 @@
-/*
-Hand-built OpenAPI 3.1 document from exposed MCP tools.
-*/
-
-import { collectMcpTools } from "../mcp/tools.ts";
-import type { CliProgram } from "../types.ts";
-import { dereferenceJsonSchema } from "./schema-deref.ts";
-
-const JSON_CONTENT_TYPE = "application/json; charset=utf-8";
-
-/** Resolves the effective API content type for OpenAPI response mapping. */
-function effectiveApiContentType(tool: ReturnType<typeof collectMcpTools>[number]): string {
-  return tool.leaf.apiResponse?.contentType ?? "application/json";
-}
-
-/** Builds an OpenAPI 3.1 response schema for a tool's success payload. */
-function buildSuccessResponse(tool: ReturnType<typeof collectMcpTools>[number]): Record<string, unknown> {
-  const contentType = effectiveApiContentType(tool);
-  const media: Record<string, unknown> = {};
-
-  if (contentType.includes("application/json")) {
-    const outputSchema = tool.outputSchema ?? { type: "object" };
-    media[contentType] = {
-      schema: dereferenceJsonSchema(outputSchema),
-    };
-  } else if (contentType.includes("text/html")) {
-    media[contentType] = { schema: { type: "string" } };
-  } else {
-    media[contentType] = { schema: { type: "string", format: "binary" } };
-  }
-
-  return {
-    description: "Successful tool invocation",
-    content: media,
-  };
-}
-
-/** Generates an OpenAPI 3.1 document for the program's exposed tools. */
-export function generateOpenApi(program: CliProgram): Record<string, unknown> {
-  const tools = collectMcpTools(program);
-  const paths: Record<string, unknown> = {};
-
-  for (const tool of tools) {
-    const pathKey = `/tools/${tool.apiName}`;
-    paths[pathKey] = {
-      post: {
-        operationId: tool.apiName,
-        summary: tool.description,
-        requestBody: {
-          required: false,
-          content: {
-            [JSON_CONTENT_TYPE]: {
-              schema: dereferenceJsonSchema(tool.inputSchema),
-            },
-          },
-        },
-        responses: {
-          "200": buildSuccessResponse(tool),
-          "400": {
-            description: "Invalid arguments or help requested",
-            content: {
-              [JSON_CONTENT_TYPE]: {
-                schema: {
-                  type: "object",
-                  properties: {
-                    error: { type: "string" },
-                    exitCode: { type: "integer" },
-                  },
-                  required: ["error"],
-                },
-              },
-            },
-          },
-          "404": {
-            description: "Unknown tool",
-            content: {
-              [JSON_CONTENT_TYPE]: {
-                schema: {
-                  type: "object",
-                  properties: { error: { type: "string" } },
-                  required: ["error"],
-                },
-              },
-            },
-          },
-          "500": {
-            description: "Handler error",
-            content: {
-              [JSON_CONTENT_TYPE]: {
-                schema: {
-                  type: "object",
-                  properties: { error: { type: "string" } },
-                  required: ["error"],
-                },
-              },
-            },
-          },
-        },
-      },
-    };
-  }
-
-  return {
-    openapi: "3.1.0",
-    info: {
-      title: program.key,
-      version: program.version,
-      description: program.description,
-    },
-    paths,
-  };
-}
-
-/** Pretty-printed OpenAPI JSON (same document as `GET /openapi.json`). */
-export function openApiJson(program: CliProgram): string {
-  return `${JSON.stringify(generateOpenApi(program), null, 2)}\n`;
-}

package/src/api/server.ts

@@ -1,120 +0,0 @@
-/*
-HTTP tool server for ArgsBarg programs: health, OpenAPI, and tool invocation.
-*/
-
-import type { Cli } from "../cli.ts";
-import {
-  executeHeadlessToolCall,
-  headlessFailureToHttpResponse,
-  headlessSuccessToHttpResponse,
-  lookupHeadlessTool,
-} from "../headless/tool-call.ts";
-import type { CliProgram } from "../types.ts";
-import { generateOpenApi } from "./openapi.ts";
-import { API_CORS_HEADERS, apiDocsHtml, apiErrorResponse, apiOptionsResponse } from "./result.ts";
-
-const DEFAULT_HOST = "127.0.0.1";
-const DEFAULT_PORT = 3000;
-
-/** Resolved listen address for the HTTP API server. */
-export function resolveApiListenAddress(program: CliProgram): { hostname: string; port: number } {
-  const config = program.apiServer;
-  return {
-    hostname: config?.host ?? DEFAULT_HOST,
-    port: config?.port ?? DEFAULT_PORT,
-  };
-}
-
-/** Writes a JSON HTTP response with CORS headers. */
-function jsonResponse(status: number, body: unknown): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: {
-      ...API_CORS_HEADERS,
-      "content-type": "application/json; charset=utf-8",
-    },
-  });
-}
-
-/** Handles one HTTP request for the API server. */
-export async function handleApiRequest(cli: Cli, request: Request): Promise<Response> {
-  if (request.method === "OPTIONS") {
-    return apiOptionsResponse();
-  }
-
-  const root = cli.program;
-  const url = new URL(request.url);
-  const path = url.pathname;
-
-  if (request.method === "GET" && path === "/health") {
-    return jsonResponse(200, { ok: true });
-  }
-
-  if (request.method === "GET" && path === "/openapi.json") {
-    return jsonResponse(200, generateOpenApi(root));
-  }
-
-  if (request.method === "GET" && path === "/openapi-browser") {
-    return new Response(apiDocsHtml(), {
-      status: 200,
-      headers: {
-        ...API_CORS_HEADERS,
-        "content-type": "text/html; charset=utf-8",
-      },
-    });
-  }
-
-  const toolPathMatch = /^\/tools\/([^/]+)$/.exec(path);
-  if (request.method === "POST" && toolPathMatch) {
-    const toolName = decodeURIComponent(toolPathMatch[1] ?? "");
-    let body: unknown = {};
-    const rawBody = await request.text();
-    if (rawBody.trim().length > 0) {
-      try {
-        body = JSON.parse(rawBody);
-      } catch {
-        return apiErrorResponse(400, { error: "Invalid JSON body" });
-      }
-    }
-    if (typeof body !== "object" || body === null || Array.isArray(body)) {
-      return apiErrorResponse(400, { error: "Request body must be a JSON object" });
-    }
-    return invokeApiTool(cli, toolName, body as Record<string, unknown>);
-  }
-
-  if (path === "/tools" || path.startsWith("/tools/")) {
-    return apiErrorResponse(405, { error: "Method not allowed" });
-  }
-
-  return apiErrorResponse(404, { error: "Not found" });
-}
-
-/** Resolves a tool and runs it through the shared headless invoke path. */
-async function invokeApiTool(cli: Cli, toolName: string, args: Record<string, unknown>): Promise<Response> {
-  const lookup = lookupHeadlessTool(cli.program, toolName, "api");
-  if (!lookup.ok) {
-    if (lookup.kind === "unknown") {
-      return apiErrorResponse(404, { error: lookup.message });
-    }
-    return apiErrorResponse(503, { error: lookup.message });
-  }
-
-  const result = await executeHeadlessToolCall(cli, lookup.tool, args, "api");
-  if (result.ok) {
-    return headlessSuccessToHttpResponse(result, lookup.tool.leaf.apiResponse);
-  }
-  return headlessFailureToHttpResponse(result);
-}
-
-/** Runs the HTTP API server until the process is interrupted. */
-export async function apiServeHttp(cli: Cli): Promise<never> {
-  const { hostname, port } = resolveApiListenAddress(cli.program);
-  const server = Bun.serve({
-    hostname,
-    port,
-    fetch: (request) => handleApiRequest(cli, request),
-  });
-  process.stderr.write(`HTTP API listening on http://${server.hostname}:${server.port}\n`);
-  await new Promise<never>(() => {});
-  throw new Error("HTTP API server stopped unexpectedly");
-}

package/src/builtins/api.ts

@@ -1,38 +0,0 @@
-import { resolveApiListenAddress } from "../api/server.ts";
-import { resolveCapabilities } from "../capabilities.ts";
-import { docsEnabled } from "../docs/resolve.ts";
-import { CliFallbackMode, type CliLeaf, type CliProgram, type CliRouter } from "../types.ts";
-
-/** Built-in `api` router: bare `myapp api` runs the HTTP server (via hidden `serve` fallback). */
-export function cliBuiltinApiCommand(program: CliProgram): CliRouter {
-  const caps = resolveCapabilities(program);
-  const { hostname, port } = resolveApiListenAddress(program);
-  const lines = [
-    `HTTP tool server on http://${hostname}:${port}.`,
-    "",
-    "Endpoints: GET /health, GET /openapi.json, GET /openapi-browser, POST /tools/:name",
-    "",
-  ];
-  if (caps.configure) {
-    lines.push("Configure app settings:", "", "  {argsbarg:program} configure", "");
-  }
-  if (docsEnabled(program)) {
-    lines.push("Full setup guide: {argsbarg:program} docs http");
-  }
-
-  const serve: CliLeaf = {
-    key: "serve",
-    hidden: true,
-    description: "Run as an HTTP API server for tools.",
-    handler: () => {},
-  };
-
-  return {
-    key: "api",
-    description: "HTTP API server for tools.",
-    notes: lines.join("\n"),
-    fallbackCommand: "serve",
-    fallbackMode: CliFallbackMode.MissingOnly,
-    commands: [serve],
-  };
-}

package/src/hidden.ts

@@ -1,30 +0,0 @@
-/*
-Filters hidden commands and options from presentation surfaces (help, schema, completions).
-Parsing still uses the full tree via cliParseRoot.
-*/
-
-import type { CliNode, CliOption } from "./types.ts";
-import { isCliRouter } from "./types.ts";
-
-/** Options visible in help, schema, completions, and MCP tool schemas. */
-export function visibleOptions(options: CliOption[] | undefined): CliOption[] {
-  return (options ?? []).filter((o) => !o.hidden);
-}
-
-/** Strips hidden commands and options from one node for presentation export. */
-export function presentationNode(node: CliNode): CliNode | null {
-  if (node.hidden) {
-    return null;
-  }
-  const options = visibleOptions(node.options);
-  if (isCliRouter(node)) {
-    const commands = node.commands.map((ch) => presentationNode(ch)).filter((ch): ch is CliNode => ch !== null);
-    return { ...node, options, commands };
-  }
-  return { ...node, options };
-}
-
-/** Subcommands visible in help listings (parent may be any node in the parse tree). */
-export function visibleSubcommands(cmds: CliNode[]): CliNode[] {
-  return cmds.filter((c) => !c.hidden);
-}

package/src/install/plan.ts

@@ -1,53 +0,0 @@
-import { resolveCapabilities } from "../capabilities.ts";
-import type { CliProgram } from "../types.ts";
-import type { InstallPaths } from "./paths.ts";
-import { buildInstallPlanFromTargets } from "./target-plan-build.ts";
-import type { InstallAction, InstallOpts } from "./target-types.ts";
-
-export type { InstallAction, InstallActionKind, InstallOpts } from "./target-types.ts";
-
-/** Builds install actions for normal mode (--all / scoped targets). */
-export function buildInstallPlan(root: CliProgram, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
-  return buildInstallPlanFromTargets(root, paths, opts);
-}
-
-/** Builds update/reinstall actions; greenfield fallback when nothing detected. */
-export function buildUpdatePlan(root: CliProgram, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
-  const refresh = buildInstallPlanFromTargets(root, paths, {
-    ...opts,
-    reinstall: true,
-    all: true,
-  });
-  if (refresh.length > 0) {
-    return refresh;
-  }
-  return buildInstallPlanFromTargets(root, paths, { ...opts, reinstall: false, all: true });
-}
-
-/** @deprecated Use resolveInstallPlanMode + shouldIncludeArtifact. */
-export function wantsInstallApp(_opts: InstallOpts): boolean {
-  return false;
-}
-
-/** @deprecated Use {@link wantsInstallApp}. */
-export const wantsInstallBin = wantsInstallApp;
-
-/** @deprecated Use resolveInstallPlanMode + shouldIncludeArtifact. */
-export function wantsInstallCompletions(_opts: InstallOpts): boolean {
-  return false;
-}
-
-/** @deprecated Use resolveInstallPlanMode + shouldIncludeArtifact. */
-export function wantsInstallSkill(opts: InstallOpts): boolean {
-  return !!(opts.all || opts.skill);
-}
-
-/** @deprecated Use resolveInstallPlanMode + shouldIncludeArtifact. */
-export function wantsInstallMcp(opts: InstallOpts, root: CliProgram): boolean {
-  return !!(opts.mcp || opts.all) && resolveCapabilities(root).mcp;
-}
-
-/** @deprecated Use configure target + shouldIncludeArtifact. */
-export function wantsUninstallConfig(opts: InstallOpts, root: CliProgram): boolean {
-  return !!(opts.configure || opts.all) && root.appConfig !== undefined;
-}