@codai/axiom-mcp 1.0.23 → 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,133 @@
+import { ErrorCode } from "@codai/axiom-schema";
+import { z } from "zod";
+import { GuardOptions } from "@codai/axiom-checks";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import "@modelcontextprotocol/sdk/types.js";
+//#region src/jsonschema.d.ts
+export declare const SCHEMA_KINDS: readonly ["Plan", "Manifest", "ManifestBundle", "CheckReport", "ApplyResult", "Profile", "Journal"];
+type SchemaKind = (typeof SCHEMA_KINDS)[number];
+export declare function isSchemaKind(v: unknown): v is SchemaKind;
+/** Draft 2020-12 JSON Schema, byte-identical to `packages/schema/schemas/<kind>.schema.json`. */
+export declare function jsonSchemaFor(kind: SchemaKind): Record<string, unknown>;
+//#endregion
+//#region src/log.d.ts
+/**
+ * stderr-only JSON-lines logger. stdout belongs to the MCP transport; nothing in
+ * this package may write there except the transport itself (and CLI verbs).
+ */
+export declare const LOG_LEVELS: readonly ["error", "warn", "info", "debug"];
+type LogLevel = (typeof LOG_LEVELS)[number];
+interface Logger {
+  readonly level: LogLevel;
+  error(msg: string, fields?: Record<string, unknown>): void;
+  warn(msg: string, fields?: Record<string, unknown>): void;
+  info(msg: string, fields?: Record<string, unknown>): void;
+  debug(msg: string, fields?: Record<string, unknown>): void;
+}
+export declare function isLogLevel(v: unknown): v is LogLevel;
+interface LoggerOptions {
+  level?: LogLevel;
+  /** Test hook; defaults to `process.stderr.write`. */
+  write?: (line: string) => void;
+  now?: () => string;
+}
+export declare function createLogger(opts?: LoggerOptions): Logger;
+//#endregion
+//#region src/roots.d.ts
+/** Frozen allowlist of realpath'd root directories (§5.3). */
+interface RootsPolicy {
+  readonly roots: ReadonlySet<string>;
+}
+interface ResolvedRoot {
+  /** realpath of the requested directory (or the single allowlisted root). */
+  rootReal: string;
+  /** The allowlisted root that contains `rootReal` (equal to it in the common case). */
+  effectiveRoot: string;
+}
+/** True iff `child` equals `parent` or lies inside it (case-insensitive on win32). */
+export declare function isSameOrInside(parent: string, child: string): boolean;
+/** Build the policy from `--root <abs>` arguments. Each must exist and be a directory. */
+export declare function createRootsPolicy(rootArgs: readonly string[]): Promise<RootsPolicy>;
+/**
+ * Resolve a tool's `root` argument against the allowlist. No env fallback, no cwd:
+ * none requested + one root → that root; none + many → ERR_ROOT_REQUIRED;
+ * requested → realpath, must equal or be inside an allowlisted root → else ERR_ROOT_NOT_ALLOWED.
+ */
+export declare function resolveRoot(policy: RootsPolicy, requested?: string): Promise<ResolvedRoot>;
+//#endregion
+//#region src/tools.d.ts
+/** Hard cap on any single `bundle`/`plan` argument, measured as UTF-8 JSON bytes (§(f) payload size). */
+export declare const BUNDLE_BYTES_MAX: number;
+/** Findings/errors echoed in the text summary. */
+export declare const SUMMARY_LIST_MAX = 20;
+type RiskClass = "READ" | "ACT" | "SENSITIVE";
+interface ToolAnnotations {
+  readOnlyHint: boolean;
+  destructiveHint: boolean;
+  idempotentHint: boolean;
+  openWorldHint: boolean;
+}
+interface ToolContext {
+  policy: RootsPolicy;
+  log: Logger;
+  /** Roots that received a stored manifest/report during this process (for DigestRef lookups). */
+  seenRoots: Set<string>;
+  /** `--allow-guards` / `--guard-allowlist` from startup (§3.2); absent = guards disabled. */
+  guards?: GuardOptions;
+}
+interface ToolDef<I extends z.ZodRawShape = z.ZodRawShape, O extends z.ZodType = z.ZodType> {
+  name: string;
+  title: string;
+  description: string;
+  inputSchema: I;
+  outputSchema: O;
+  annotations: ToolAnnotations;
+  riskClass: RiskClass;
+  handler: (ctx: ToolContext, input: z.output<z.ZodObject<I>>) => Promise<z.output<O>>;
+  /** Small text projection of the output for `content[0].text`. Never the whole bundle. */
+  summarize: (output: z.output<O>) => unknown;
+}
+type AnyToolDef = ToolDef<z.ZodRawShape, z.ZodType>;
+export declare function riskClassOf(a: ToolAnnotations): RiskClass;
+export declare const TOOL_DEFS: readonly AnyToolDef[];
+export declare function toolByName(name: string): AnyToolDef | undefined;
+//#endregion
+//#region src/server.d.ts
+export declare const SERVER_NAME = "axiom";
+export declare const SERVER_VERSION: string;
+interface CreateServerOptions {
+  log?: Logger;
+  tools?: readonly AnyToolDef[];
+  /** `--allow-guards` / `--guard-allowlist` (§3.2). Omit to keep guards disabled. */
+  guards?: ToolContext["guards"];
+}
+interface StructuredError {
+  code: ErrorCode;
+  message: string;
+  path?: string;
+  details?: Record<string, unknown>;
+}
+export declare function toStructuredError(err: unknown): StructuredError;
+export declare function createServer(policy: RootsPolicy, opts?: CreateServerOptions): McpServer;
+//#endregion
+//#region src/spec.d.ts
+/** One entry of `spec/tools.json` — the codai agent-core tool manifest shape. */
+interface ToolSpecEntry {
+  name: string;
+  description: string;
+  riskClass: "READ" | "ACT" | "SENSITIVE";
+  annotations: {
+    readOnlyHint: boolean;
+    destructiveHint: boolean;
+    idempotentHint: boolean;
+    openWorldHint: boolean;
+  };
+  inputSchema: Record<string, unknown>;
+  outputSchema: Record<string, unknown>;
+}
+export declare function buildToolsSpec(): ToolSpecEntry[];
+/** Stable text form (2-space JSON + trailing newline) used both by the generator and the parity test. */
+export declare function renderToolsSpec(): string;
+//#endregion
+export type { AnyToolDef, CreateServerOptions, LogLevel, Logger, ResolvedRoot, RiskClass, RootsPolicy, SchemaKind, StructuredError, ToolAnnotations, ToolContext, ToolDef, ToolSpecEntry };
+//# sourceMappingURL=index.d.ts.map