@phyzess/pappra 0.0.0-stage → 0.1.0-beta.2

package/dist/schemas/doctor.d.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+export declare const DOCTOR_REPORT_SCHEMA = "pappra/doctor-report/1";
+export declare const doctorCheckStatusSchema: z.ZodEnum<{
+    error: "error";
+    ok: "ok";
+    partial: "partial";
+    unknown: "unknown";
+    unsupported: "unsupported";
+    warning: "warning";
+}>;
+export declare const doctorSeveritySchema: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    warning: "warning";
+}>;
+export declare const doctorCheckSchema: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        ok: "ok";
+        partial: "partial";
+        unknown: "unknown";
+        unsupported: "unsupported";
+        warning: "warning";
+    }>;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+    title: z.ZodString;
+    summary: z.ZodString;
+    source: z.ZodString;
+    observedAt: z.ZodISODateTime;
+    coverage: z.ZodNullable<z.ZodString>;
+    evidence: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            file: "file";
+            git: "git";
+            "native-event": "native-event";
+            "runtime-probe": "runtime-probe";
+        }>;
+        ref: z.ZodString;
+        digest: z.ZodNullable<z.ZodString>;
+        observedAt: z.ZodISODateTime;
+        scope: z.ZodEnum<{
+            declared: "declared";
+            "live-owned": "live-owned";
+            persisted: "persisted";
+        }>;
+    }, z.core.$strict>>;
+    nextActions: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type DoctorCheckStatus = z.infer<typeof doctorCheckStatusSchema>;
+export type DoctorSeverity = z.infer<typeof doctorSeveritySchema>;
+export type DoctorCheck = z.infer<typeof doctorCheckSchema>;
+export declare const doctorMachineRuntimeSchema: z.ZodObject<{
+    version: z.ZodString;
+    executable: z.ZodString;
+    verifiedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const doctorReportSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/doctor-report/1">;
+    generatedAt: z.ZodISODateTime;
+    requestedRoot: z.ZodString;
+    workspace: z.ZodObject<{
+        root: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            incomplete: "incomplete";
+            missing: "missing";
+            registered: "registered";
+            unavailable: "unavailable";
+        }>;
+        configPath: z.ZodNullable<z.ZodString>;
+        machinePath: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    runtime: z.ZodObject<{
+        targetVersion: z.ZodNullable<z.ZodString>;
+        machineRuntime: z.ZodNullable<z.ZodObject<{
+            version: z.ZodString;
+            executable: z.ZodString;
+            verifiedAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        dataDir: z.ZodString;
+        passiveStatus: z.ZodNullable<z.ZodEnum<{
+            "content-match": "content-match";
+            corrupt: "corrupt";
+            locked: "locked";
+            missing: "missing";
+            partial: "partial";
+            unreadable: "unreadable";
+            "version-mismatch": "version-mismatch";
+        }>>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        checked: z.ZodArray<z.ZodString>;
+        notChecked: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodString;
+        status: z.ZodEnum<{
+            error: "error";
+            ok: "ok";
+            partial: "partial";
+            unknown: "unknown";
+            unsupported: "unsupported";
+            warning: "warning";
+        }>;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        title: z.ZodString;
+        summary: z.ZodString;
+        source: z.ZodString;
+        observedAt: z.ZodISODateTime;
+        coverage: z.ZodNullable<z.ZodString>;
+        evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                git: "git";
+                "native-event": "native-event";
+                "runtime-probe": "runtime-probe";
+            }>;
+            ref: z.ZodString;
+            digest: z.ZodNullable<z.ZodString>;
+            observedAt: z.ZodISODateTime;
+            scope: z.ZodEnum<{
+                declared: "declared";
+                "live-owned": "live-owned";
+                persisted: "persisted";
+            }>;
+        }, z.core.$strict>>;
+        nextActions: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    summary: z.ZodObject<{
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            needs_attention: "needs_attention";
+            ok: "ok";
+        }>;
+        exitCode: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        counts: z.ZodObject<{
+            ok: z.ZodNumber;
+            warning: z.ZodNumber;
+            error: z.ZodNumber;
+            unknown: z.ZodNumber;
+            partial: z.ZodNumber;
+            unsupported: z.ZodNumber;
+        }, z.core.$strict>;
+        nextActions: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type DoctorReport = z.infer<typeof doctorReportSchema>;

package/dist/schemas/doctor.js

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { evidenceRefSchema } from './evidence.js';
+export const DOCTOR_REPORT_SCHEMA = 'pappra/doctor-report/1';
+export const doctorCheckStatusSchema = z.enum([
+    'ok',
+    'warning',
+    'error',
+    'unknown',
+    'partial',
+    'unsupported',
+]);
+export const doctorSeveritySchema = z.enum(['info', 'warning', 'error']);
+export const doctorCheckSchema = z.strictObject({
+    id: z.string().min(1).max(128),
+    code: z.string().min(1).max(128),
+    status: doctorCheckStatusSchema,
+    severity: doctorSeveritySchema,
+    title: z.string().min(1).max(256),
+    summary: z.string().min(1).max(4096),
+    source: z.string().min(1).max(4096),
+    observedAt: z.iso.datetime({ offset: true }),
+    coverage: z.string().min(1).max(256).nullable(),
+    evidence: z.array(evidenceRefSchema).max(32),
+    nextActions: z.array(z.string().min(1).max(1024)).max(16),
+});
+export const doctorMachineRuntimeSchema = z.strictObject({
+    version: z.string().min(1).max(128),
+    executable: z.string().min(1).max(4096),
+    verifiedAt: z.iso.datetime({ offset: true }),
+});
+export const doctorReportSchema = z.strictObject({
+    schema: z.literal(DOCTOR_REPORT_SCHEMA),
+    generatedAt: z.iso.datetime({ offset: true }),
+    requestedRoot: z.string().min(1).max(4096),
+    workspace: z.strictObject({
+        root: z.string().min(1).max(4096).nullable(),
+        state: z.enum(['registered', 'missing', 'incomplete', 'unavailable']),
+        configPath: z.string().min(1).max(4096).nullable(),
+        machinePath: z.string().min(1).max(4096).nullable(),
+    }),
+    runtime: z.strictObject({
+        targetVersion: z.string().min(1).max(128).nullable(),
+        machineRuntime: doctorMachineRuntimeSchema.nullable(),
+        dataDir: z.string().min(1).max(4096),
+        passiveStatus: z
+            .enum([
+            'missing',
+            'content-match',
+            'version-mismatch',
+            'corrupt',
+            'locked',
+            'partial',
+            'unreadable',
+        ])
+            .nullable(),
+    }),
+    scope: z.strictObject({
+        checked: z.array(z.string().min(1).max(512)).max(64),
+        notChecked: z.array(z.string().min(1).max(512)).max(64),
+    }),
+    checks: z.array(doctorCheckSchema).max(128),
+    summary: z.strictObject({
+        status: z.enum(['ok', 'needs_attention', 'blocked']),
+        exitCode: z.union([z.literal(0), z.literal(1)]),
+        counts: z.strictObject({
+            ok: z.number().int().nonnegative(),
+            warning: z.number().int().nonnegative(),
+            error: z.number().int().nonnegative(),
+            unknown: z.number().int().nonnegative(),
+            partial: z.number().int().nonnegative(),
+            unsupported: z.number().int().nonnegative(),
+        }),
+        nextActions: z.array(z.string().min(1).max(1024)).max(16),
+    }),
+});