@detent/sdk 0.1.0

package/src/lib/security.ts

@@ -0,0 +1,237 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+type OAuth2PasswordFlow = {
+  username: string;
+  password: string;
+  clientID?: string | undefined;
+  clientSecret?: string | undefined;
+  tokenURL: string;
+};
+
+export enum SecurityErrorCode {
+  Incomplete = "incomplete",
+  UnrecognisedSecurityType = "unrecognized_security_type",
+}
+
+export class SecurityError extends Error {
+  constructor(
+    public code: SecurityErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = "SecurityError";
+  }
+
+  static incomplete(): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.Incomplete,
+      "Security requirements not met in order to perform the operation",
+    );
+  }
+  static unrecognizedType(type: string): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.UnrecognisedSecurityType,
+      `Unrecognised security type: ${type}`,
+    );
+  }
+}
+
+export type SecurityState = {
+  basic: { username?: string | undefined; password?: string | undefined };
+  headers: Record<string, string>;
+  queryParams: Record<string, string>;
+  cookies: Record<string, string>;
+  oauth2: ({ type: "password" } & OAuth2PasswordFlow) | { type: "none" };
+};
+
+type SecurityInputBasic = {
+  type: "http:basic";
+  value:
+    | { username?: string | undefined; password?: string | undefined }
+    | null
+    | undefined;
+};
+
+type SecurityInputBearer = {
+  type: "http:bearer";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputAPIKey = {
+  type: "apiKey:header" | "apiKey:query" | "apiKey:cookie";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOIDC = {
+  type: "openIdConnect";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2 = {
+  type: "oauth2";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2ClientCredentials = {
+  type: "oauth2:client_credentials";
+  value:
+    | {
+      clientID?: string | undefined;
+      clientSecret?: string | undefined;
+    }
+    | null
+    | string
+    | undefined;
+  fieldName?: string;
+};
+
+type SecurityInputOAuth2PasswordCredentials = {
+  type: "oauth2:password";
+  value:
+    | string
+    | null
+    | undefined;
+  fieldName?: string;
+};
+
+type SecurityInputCustom = {
+  type: "http:custom";
+  value: any | null | undefined;
+  fieldName?: string;
+};
+
+export type SecurityInput =
+  | SecurityInputBasic
+  | SecurityInputBearer
+  | SecurityInputAPIKey
+  | SecurityInputOAuth2
+  | SecurityInputOAuth2ClientCredentials
+  | SecurityInputOAuth2PasswordCredentials
+  | SecurityInputOIDC
+  | SecurityInputCustom;
+
+export function resolveSecurity(
+  ...options: SecurityInput[][]
+): SecurityState | null {
+  const state: SecurityState = {
+    basic: {},
+    headers: {},
+    queryParams: {},
+    cookies: {},
+    oauth2: { type: "none" },
+  };
+
+  const option = options.find((opts) => {
+    return opts.every((o) => {
+      if (o.value == null) {
+        return false;
+      } else if (o.type === "http:basic") {
+        return o.value.username != null || o.value.password != null;
+      } else if (o.type === "http:custom") {
+        return null;
+      } else if (o.type === "oauth2:password") {
+        return (
+          typeof o.value === "string" && !!o.value
+        );
+      } else if (o.type === "oauth2:client_credentials") {
+        if (typeof o.value == "string") {
+          return !!o.value;
+        }
+        return o.value.clientID != null || o.value.clientSecret != null;
+      } else if (typeof o.value === "string") {
+        return !!o.value;
+      } else {
+        throw new Error(
+          `Unrecognized security type: ${o.type} (value type: ${typeof o
+            .value})`,
+        );
+      }
+    });
+  });
+  if (option == null) {
+    return null;
+  }
+
+  option.forEach((spec) => {
+    if (spec.value == null) {
+      return;
+    }
+
+    const { type } = spec;
+
+    switch (type) {
+      case "apiKey:header":
+        state.headers[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:query":
+        state.queryParams[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:cookie":
+        state.cookies[spec.fieldName] = spec.value;
+        break;
+      case "http:basic":
+        applyBasic(state, spec);
+        break;
+      case "http:custom":
+        break;
+      case "http:bearer":
+        applyBearer(state, spec);
+        break;
+      case "oauth2":
+        applyBearer(state, spec);
+        break;
+      case "oauth2:password":
+        applyBearer(state, spec);
+        break;
+      case "oauth2:client_credentials":
+        break;
+      case "openIdConnect":
+        applyBearer(state, spec);
+        break;
+      default:
+        spec satisfies never;
+        throw SecurityError.unrecognizedType(type);
+    }
+  });
+
+  return state;
+}
+
+function applyBasic(
+  state: SecurityState,
+  spec: SecurityInputBasic,
+) {
+  if (spec.value == null) {
+    return;
+  }
+
+  state.basic = spec.value;
+}
+
+function applyBearer(
+  state: SecurityState,
+  spec:
+    | SecurityInputBearer
+    | SecurityInputOAuth2
+    | SecurityInputOIDC
+    | SecurityInputOAuth2PasswordCredentials,
+) {
+  if (typeof spec.value !== "string" || !spec.value) {
+    return;
+  }
+
+  let value = spec.value;
+  if (value.slice(0, 7).toLowerCase() !== "bearer ") {
+    value = `Bearer ${value}`;
+  }
+
+  if (spec.fieldName !== undefined) {
+    state.headers[spec.fieldName] = value;
+  }
+}

package/src/lib/url.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export type Params = Partial<Record<string, string | number>>;
+
+export function pathToFunc(
+  pathPattern: string,
+  options?: { charEncoding?: "percent" | "none" },
+): (params?: Params) => string {
+  const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
+
+  return function buildURLPath(params: Record<string, unknown> = {}): string {
+    return pathPattern.replace(paramRE, function (_, placeholder) {
+      if (!hasOwn.call(params, placeholder)) {
+        throw new Error(`Parameter '${placeholder}' is required`);
+      }
+
+      const value = params[placeholder];
+      if (typeof value !== "string" && typeof value !== "number") {
+        throw new Error(
+          `Parameter '${placeholder}' must be a string or number`,
+        );
+      }
+
+      return options?.charEncoding === "percent"
+        ? encodeURIComponent(`${value}`)
+        : `${value}`;
+    });
+  };
+}

package/src/models/detected-tool.ts

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../types/enums.js";
+
+/**
+ * Hint for which tool produced the output. Auto-detected if omitted.
+ */
+export const DetectedTool = {
+  Eslint: "eslint",
+  Vitest: "vitest",
+  Typescript: "typescript",
+  Cargo: "cargo",
+  Golangci: "golangci",
+} as const;
+/**
+ * Hint for which tool produced the output. Auto-detected if omitted.
+ */
+export type DetectedTool = ClosedEnum<typeof DetectedTool>;
+
+/** @internal */
+export const DetectedTool$outboundSchema: z.ZodMiniEnum<typeof DetectedTool> = z
+  .enum(DetectedTool);

package/src/models/diagnostic-lite.ts

@@ -0,0 +1,57 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type DiagnosticLite = {
+  /**
+   * Error or warning message
+   */
+  message: string;
+  /**
+   * File path where the issue occurred
+   */
+  filePath?: string | undefined;
+  /**
+   * Line number (1-indexed)
+   */
+  line?: number | undefined;
+  /**
+   * Column number (1-indexed)
+   */
+  column?: number | undefined;
+};
+
+/** @internal */
+export const DiagnosticLite$inboundSchema: z.ZodMiniType<
+  DiagnosticLite,
+  unknown
+> = z.pipe(
+  z.object({
+    message: types.string(),
+    file_path: types.optional(types.string()),
+    line: types.optional(types.number()),
+    column: types.optional(types.number()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "file_path": "filePath",
+    });
+  }),
+);
+
+export function diagnosticLiteFromJSON(
+  jsonString: string,
+): SafeParseResult<DiagnosticLite, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DiagnosticLite$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DiagnosticLite' from JSON`,
+  );
+}

package/src/models/diagnostic-summary.ts

@@ -0,0 +1,47 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+/**
+ * Aggregated counts
+ */
+export type DiagnosticSummary = {
+  /**
+   * Total number of diagnostics
+   */
+  total: number;
+  /**
+   * Number of errors
+   */
+  errors: number;
+  /**
+   * Number of warnings
+   */
+  warnings: number;
+};
+
+/** @internal */
+export const DiagnosticSummary$inboundSchema: z.ZodMiniType<
+  DiagnosticSummary,
+  unknown
+> = z.object({
+  total: types.number(),
+  errors: types.number(),
+  warnings: types.number(),
+});
+
+export function diagnosticSummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<DiagnosticSummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DiagnosticSummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DiagnosticSummary' from JSON`,
+  );
+}

package/src/models/diagnostic.ts

@@ -0,0 +1,83 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import { Severity, Severity$inboundSchema } from "./severity.js";
+
+export type Diagnostic = {
+  /**
+   * Error or warning message
+   */
+  message: string;
+  /**
+   * File path where the issue occurred
+   */
+  filePath?: string | undefined;
+  /**
+   * Line number (1-indexed)
+   */
+  line?: number | undefined;
+  /**
+   * Column number (1-indexed)
+   */
+  column?: number | undefined;
+  /**
+   * Issue severity level
+   */
+  severity: Severity;
+  /**
+   * Tool-specific rule identifier
+   */
+  ruleId?: string | undefined;
+  /**
+   * Stack trace if available (e.g., for test failures)
+   */
+  stackTrace?: string | undefined;
+  /**
+   * Suggested fixes from the tool
+   */
+  suggestions?: Array<string> | undefined;
+  /**
+   * Whether the tool can auto-fix this issue
+   */
+  fixable?: boolean | undefined;
+};
+
+/** @internal */
+export const Diagnostic$inboundSchema: z.ZodMiniType<Diagnostic, unknown> = z
+  .pipe(
+    z.object({
+      message: types.string(),
+      file_path: types.optional(types.string()),
+      line: types.optional(types.number()),
+      column: types.optional(types.number()),
+      severity: Severity$inboundSchema,
+      rule_id: types.optional(types.string()),
+      stack_trace: types.optional(types.string()),
+      suggestions: types.optional(z.array(types.string())),
+      fixable: types.optional(types.boolean()),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "file_path": "filePath",
+        "rule_id": "ruleId",
+        "stack_trace": "stackTrace",
+      });
+    }),
+  );
+
+export function diagnosticFromJSON(
+  jsonString: string,
+): SafeParseResult<Diagnostic, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Diagnostic$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Diagnostic' from JSON`,
+  );
+}

package/src/models/diagnostics-request.ts

@@ -0,0 +1,47 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { DetectedTool, DetectedTool$outboundSchema } from "./detected-tool.js";
+import { ModeEnum, ModeEnum$outboundSchema } from "./mode-enum.js";
+
+export type DiagnosticsRequest = {
+  /**
+   * Raw CI/build log content to parse
+   */
+  content: string;
+  /**
+   * Hint for which tool produced the output. Auto-detected if omitted.
+   */
+  tool?: DetectedTool | undefined;
+  /**
+   * Response detail level. 'full' includes severity, ruleId, suggestions. 'lite' is minimal.
+   */
+  mode?: ModeEnum | undefined;
+};
+
+/** @internal */
+export type DiagnosticsRequest$Outbound = {
+  content: string;
+  tool?: string | undefined;
+  mode: string;
+};
+
+/** @internal */
+export const DiagnosticsRequest$outboundSchema: z.ZodMiniType<
+  DiagnosticsRequest$Outbound,
+  DiagnosticsRequest
+> = z.object({
+  content: z.string(),
+  tool: z.optional(DetectedTool$outboundSchema),
+  mode: z._default(ModeEnum$outboundSchema, "full"),
+});
+
+export function diagnosticsRequestToJSON(
+  diagnosticsRequest: DiagnosticsRequest,
+): string {
+  return JSON.stringify(
+    DiagnosticsRequest$outboundSchema.parse(diagnosticsRequest),
+  );
+}

package/src/models/diagnostics-response-full.ts

@@ -0,0 +1,67 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import {
+  DiagnosticSummary,
+  DiagnosticSummary$inboundSchema,
+} from "./diagnostic-summary.js";
+import { Diagnostic, Diagnostic$inboundSchema } from "./diagnostic.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type DiagnosticsResponseFull = {
+  /**
+   * Response mode indicator (discriminator)
+   */
+  mode: "full";
+  /**
+   * Tool detected from output (null if unknown)
+   */
+  detectedTool: string | null;
+  /**
+   * Parsed diagnostics from the log
+   */
+  diagnostics: Array<Diagnostic>;
+  /**
+   * Aggregated counts
+   */
+  summary: DiagnosticSummary;
+  /**
+   * True if diagnostics were truncated (max 10,000)
+   */
+  truncated: boolean;
+};
+
+/** @internal */
+export const DiagnosticsResponseFull$inboundSchema: z.ZodMiniType<
+  DiagnosticsResponseFull,
+  unknown
+> = z.pipe(
+  z.object({
+    mode: types.literal("full"),
+    detected_tool: types.nullable(types.string()),
+    diagnostics: z.array(Diagnostic$inboundSchema),
+    summary: DiagnosticSummary$inboundSchema,
+    truncated: types.boolean(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "detected_tool": "detectedTool",
+    });
+  }),
+);
+
+export function diagnosticsResponseFullFromJSON(
+  jsonString: string,
+): SafeParseResult<DiagnosticsResponseFull, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DiagnosticsResponseFull$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DiagnosticsResponseFull' from JSON`,
+  );
+}

package/src/models/diagnostics-response-lite.ts

@@ -0,0 +1,61 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import {
+  DiagnosticLite,
+  DiagnosticLite$inboundSchema,
+} from "./diagnostic-lite.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type DiagnosticsResponseLite = {
+  /**
+   * Response mode indicator (discriminator)
+   */
+  mode: "lite";
+  /**
+   * Tool detected from output (null if unknown)
+   */
+  detectedTool: string | null;
+  /**
+   * Parsed diagnostics (minimal fields)
+   */
+  diagnostics: Array<DiagnosticLite>;
+  /**
+   * True if diagnostics were truncated (max 10,000)
+   */
+  truncated: boolean;
+};
+
+/** @internal */
+export const DiagnosticsResponseLite$inboundSchema: z.ZodMiniType<
+  DiagnosticsResponseLite,
+  unknown
+> = z.pipe(
+  z.object({
+    mode: types.literal("lite"),
+    detected_tool: types.nullable(types.string()),
+    diagnostics: z.array(DiagnosticLite$inboundSchema),
+    truncated: types.boolean(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "detected_tool": "detectedTool",
+    });
+  }),
+);
+
+export function diagnosticsResponseLiteFromJSON(
+  jsonString: string,
+): SafeParseResult<DiagnosticsResponseLite, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DiagnosticsResponseLite$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DiagnosticsResponseLite' from JSON`,
+  );
+}

package/src/models/diagnostics-response.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as discriminatedUnionTypes from "../types/discriminated-union.js";
+import { discriminatedUnion } from "../types/discriminated-union.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  DiagnosticsResponseFull,
+  DiagnosticsResponseFull$inboundSchema,
+} from "./diagnostics-response-full.js";
+import {
+  DiagnosticsResponseLite,
+  DiagnosticsResponseLite$inboundSchema,
+} from "./diagnostics-response-lite.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type DiagnosticsResponse =
+  | DiagnosticsResponseFull
+  | DiagnosticsResponseLite
+  | discriminatedUnionTypes.Unknown<"mode">;
+
+/** @internal */
+export const DiagnosticsResponse$inboundSchema: z.ZodMiniType<
+  DiagnosticsResponse,
+  unknown
+> = discriminatedUnion("mode", {
+  full: DiagnosticsResponseFull$inboundSchema,
+  lite: DiagnosticsResponseLite$inboundSchema,
+});
+
+export function diagnosticsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DiagnosticsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DiagnosticsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DiagnosticsResponse' from JSON`,
+  );
+}