@webpresso/agent-kit 0.21.0

package/dist/esm/config/docs-lint/schemas/core.d.ts

@@ -0,0 +1,189 @@
+import { z } from 'zod';
+/**
+ * Frontmatter schema for core documentation files.
+ * Located at docs/*.md (root level) - VISION.md, etc.
+ */
+export declare const coreFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        draft: "draft";
+        planned: "planned";
+        "in-progress": "in-progress";
+        archived: "archived";
+        superseded: "superseded";
+        open: "open";
+        accepted: "accepted";
+        "needs-remediation": "needs-remediation";
+        monitoring: "monitoring";
+        resolved: "resolved";
+        deprecated: "deprecated";
+        current: "current";
+        complete: "complete";
+        active: "active";
+        review: "review";
+        deferred: "deferred";
+        backlog: "backlog";
+        "wont-fix": "wont-fix";
+    }>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodLiteral<"core">>;
+    last_updated: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>;
+    owner: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CoreFrontmatter = z.infer<typeof coreFrontmatter>;
+/**
+ * Frontmatter schema for README files.
+ */
+export declare const readmeFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        draft: "draft";
+        planned: "planned";
+        "in-progress": "in-progress";
+        archived: "archived";
+        superseded: "superseded";
+        open: "open";
+        accepted: "accepted";
+        "needs-remediation": "needs-remediation";
+        monitoring: "monitoring";
+        resolved: "resolved";
+        deprecated: "deprecated";
+        current: "current";
+        complete: "complete";
+        active: "active";
+        review: "review";
+        deferred: "deferred";
+        backlog: "backlog";
+        "wont-fix": "wont-fix";
+    }>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodLiteral<"readme">>;
+}, z.core.$strip>;
+export type ReadmeFrontmatter = z.infer<typeof readmeFrontmatter>;
+/**
+ * Frontmatter schema for security docs.
+ * Located in docs/security/
+ */
+export declare const securityFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        draft: "draft";
+        planned: "planned";
+        "in-progress": "in-progress";
+        archived: "archived";
+        superseded: "superseded";
+        open: "open";
+        accepted: "accepted";
+        "needs-remediation": "needs-remediation";
+        monitoring: "monitoring";
+        resolved: "resolved";
+        deprecated: "deprecated";
+        current: "current";
+        complete: "complete";
+        active: "active";
+        review: "review";
+        deferred: "deferred";
+        backlog: "backlog";
+        "wont-fix": "wont-fix";
+    }>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodLiteral<"security">>;
+    last_updated: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>;
+    severity: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        info: "info";
+        critical: "critical";
+    }>>;
+}, z.core.$strip>;
+export type SecurityFrontmatter = z.infer<typeof securityFrontmatter>;
+/**
+ * Frontmatter schema for design docs.
+ * Located in docs/design/
+ */
+export declare const designFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodLiteral<"design">>;
+    status: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        approved: "approved";
+        deprecated: "deprecated";
+        implemented: "implemented";
+    }>>;
+}, z.core.$strip>;
+export type DesignFrontmatter = z.infer<typeof designFrontmatter>;
+/**
+ * Frontmatter schema for troubleshooting docs.
+ * Located in docs/troubleshooting/
+ */
+export declare const troubleshootingFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodLiteral<"troubleshooting">>;
+    status: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        open: "open";
+        resolved: "resolved";
+        active: "active";
+        "wont-fix": "wont-fix";
+    }>>;
+    affected_versions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type TroubleshootingFrontmatter = z.infer<typeof troubleshootingFrontmatter>;
+/**
+ * Frontmatter schema for agent-guide.md (formerly AGENTS.md).
+ */
+export declare const agentsFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        draft: "draft";
+        planned: "planned";
+        "in-progress": "in-progress";
+        archived: "archived";
+        superseded: "superseded";
+        open: "open";
+        accepted: "accepted";
+        "needs-remediation": "needs-remediation";
+        monitoring: "monitoring";
+        resolved: "resolved";
+        deprecated: "deprecated";
+        current: "current";
+        complete: "complete";
+        active: "active";
+        review: "review";
+        deferred: "deferred";
+        backlog: "backlog";
+        "wont-fix": "wont-fix";
+    }>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodLiteral<"agents">>;
+    last_updated: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgentsFrontmatter = z.infer<typeof agentsFrontmatter>;
+//# sourceMappingURL=core.d.ts.map

package/dist/esm/config/docs-lint/schemas/core.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { baseFrontmatter, dateString } from './common.js';
+/**
+ * Frontmatter schema for core documentation files.
+ * Located at docs/*.md (root level) - VISION.md, etc.
+ */
+export const coreFrontmatter = baseFrontmatter.extend({
+    type: z.literal('core').optional(),
+    /** Last update date (required for core docs) */
+    last_updated: dateString,
+    /** Document owner */
+    owner: z.string().optional(),
+});
+/**
+ * Frontmatter schema for README files.
+ */
+export const readmeFrontmatter = baseFrontmatter.extend({
+    type: z.literal('readme').optional(),
+});
+/**
+ * Frontmatter schema for security docs.
+ * Located in docs/security/
+ */
+export const securityFrontmatter = baseFrontmatter.extend({
+    type: z.literal('security').optional(),
+    last_updated: dateString,
+    severity: z.enum(['critical', 'high', 'medium', 'low', 'info']).optional(),
+});
+/**
+ * Frontmatter schema for design docs.
+ * Located in docs/design/
+ */
+export const designFrontmatter = baseFrontmatter.extend({
+    type: z.literal('design').optional(),
+    status: z.enum(['draft', 'approved', 'implemented', 'deprecated']).optional(),
+});
+/**
+ * Frontmatter schema for troubleshooting docs.
+ * Located in docs/troubleshooting/
+ */
+export const troubleshootingFrontmatter = baseFrontmatter.extend({
+    type: z.literal('troubleshooting').optional(),
+    status: z.enum(['open', 'resolved', 'wont-fix', 'active', 'draft']).optional(),
+    affected_versions: z.array(z.string()).optional(),
+});
+/**
+ * Frontmatter schema for agent-guide.md (formerly AGENTS.md).
+ */
+export const agentsFrontmatter = baseFrontmatter.extend({
+    type: z.literal('agents').optional(),
+    last_updated: dateString,
+    version: z.string().optional(),
+});
+//# sourceMappingURL=core.js.map

package/dist/esm/config/docs-lint/schemas/decision.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const decisionFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodLiteral<"decision">>;
+    status: z.ZodEnum<{
+        superseded: "superseded";
+        accepted: "accepted";
+        deprecated: "deprecated";
+        proposed: "proposed";
+    }>;
+    date: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>;
+    decision: z.ZodString;
+}, z.core.$strip>;
+//# sourceMappingURL=decision.d.ts.map

package/dist/esm/config/docs-lint/schemas/decision.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { baseFrontmatter, dateString } from './common.js';
+export const decisionFrontmatter = baseFrontmatter.extend({
+    type: z.literal('decision').optional(),
+    status: z.enum(['proposed', 'accepted', 'deprecated', 'superseded']),
+    date: dateString,
+    decision: z.string().min(1),
+});
+//# sourceMappingURL=decision.js.map

package/dist/esm/config/docs-lint/schemas/draft.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+/**
+ * Status values for draft documents
+ */
+export declare const draftStatus: z.ZodEnum<{
+    approved: "approved";
+    rejected: "rejected";
+    review: "review";
+    wip: "wip";
+}>;
+/**
+ * Schema for draft document frontmatter.
+ * Drafts are work-in-progress documents that will be merged into target files.
+ */
+export declare const draftFrontmatter: z.ZodObject<{
+    type: z.ZodLiteral<"draft">;
+    status: z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+        review: "review";
+        wip: "wip";
+    }>;
+    target: z.ZodString;
+    purpose: z.ZodString;
+    created: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    author: z.ZodOptional<z.ZodString>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    open_questions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type DraftFrontmatter = z.infer<typeof draftFrontmatter>;
+/**
+ * Required sections for draft documents
+ */
+export declare const draftSections: readonly ["Purpose", "Content"];
+//# sourceMappingURL=draft.d.ts.map

package/dist/esm/config/docs-lint/schemas/draft.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { dateString } from './common.js';
+/**
+ * Status values for draft documents
+ */
+export const draftStatus = z.enum(['wip', 'review', 'approved', 'rejected']);
+/**
+ * Schema for draft document frontmatter.
+ * Drafts are work-in-progress documents that will be merged into target files.
+ */
+export const draftFrontmatter = z.object({
+    /** Must be 'draft' */
+    type: z.literal('draft'),
+    /** Current status of the draft */
+    status: draftStatus,
+    /** Target file path where this draft will be merged */
+    target: z.string().min(1, 'Target file path is required'),
+    /** Brief description of what this draft adds/changes */
+    purpose: z.string().min(1, 'Purpose description is required'),
+    /** Creation date in YYYY-MM-DD format */
+    created: dateString,
+    /** Last update date in YYYY-MM-DD format */
+    last_updated: dateString.optional(),
+    /** Author (claude or human identifier) */
+    author: z.string().optional(),
+    /** Related documents or references */
+    related: z.array(z.string()).optional(),
+    /** Open questions that need resolution */
+    open_questions: z.array(z.string()).optional(),
+});
+/**
+ * Required sections for draft documents
+ */
+export const draftSections = ['Purpose', 'Content'];
+//# sourceMappingURL=draft.js.map

package/dist/esm/config/docs-lint/schemas/evaluation.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+/**
+ * Frontmatter schema for evaluations.
+ * Located in docs/evaluations/
+ */
+export declare const evaluationFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        draft: "draft";
+        planned: "planned";
+        "in-progress": "in-progress";
+        archived: "archived";
+        superseded: "superseded";
+        open: "open";
+        accepted: "accepted";
+        "needs-remediation": "needs-remediation";
+        monitoring: "monitoring";
+        resolved: "resolved";
+        deprecated: "deprecated";
+        current: "current";
+        complete: "complete";
+        active: "active";
+        review: "review";
+        deferred: "deferred";
+        backlog: "backlog";
+        "wont-fix": "wont-fix";
+    }>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodLiteral<"evaluation">>;
+    evaluation_date: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>;
+    model: z.ZodString;
+    evaluator_version: z.ZodOptional<z.ZodString>;
+    subject: z.ZodString;
+    scope: z.ZodString;
+    rating: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type EvaluationFrontmatter = z.infer<typeof evaluationFrontmatter>;
+//# sourceMappingURL=evaluation.d.ts.map

package/dist/esm/config/docs-lint/schemas/evaluation.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { baseFrontmatter, dateString } from './common.js';
+/**
+ * Frontmatter schema for evaluations.
+ * Located in docs/evaluations/
+ */
+export const evaluationFrontmatter = baseFrontmatter.extend({
+    type: z.literal('evaluation').optional(),
+    /** Date the evaluation was performed */
+    evaluation_date: dateString,
+    /** Model/tool being evaluated */
+    model: z.string().min(1),
+    /** Version of the evaluator (model version) */
+    evaluator_version: z.string().optional(),
+    /** Subject of the evaluation */
+    subject: z.string().min(1),
+    /** Scope of the evaluation (file, feature, etc.) */
+    scope: z.string().min(1),
+    /** Overall rating if applicable */
+    rating: z.number().min(1).max(10).optional(),
+});
+//# sourceMappingURL=evaluation.js.map

package/dist/esm/config/docs-lint/schemas/implementation-plan.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+/**
+ * Frontmatter schema for implementation plans.
+ * Located in webpresso/blueprints/.
+ */
+export declare const implementationPlanFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        blueprint: "blueprint";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        completed: "completed";
+        draft: "draft";
+        planned: "planned";
+        "in-progress": "in-progress";
+        parked: "parked";
+        archived: "archived";
+        current: "current";
+        complete: "complete";
+        deferred: "deferred";
+        deprioritized: "deprioritized";
+        future: "future";
+    }>>;
+    complexity: z.ZodOptional<z.ZodEnum<{
+        XS: "XS";
+        S: "S";
+        M: "M";
+        L: "L";
+        XL: "XL";
+    }>>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cross_repo_depends_on: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        slug: z.ZodString;
+        require_status: z.ZodOptional<z.ZodEnum<{
+            completed: "completed";
+            draft: "draft";
+            planned: "planned";
+            "in-progress": "in-progress";
+            parked: "parked";
+            archived: "archived";
+            current: "current";
+            complete: "complete";
+            deferred: "deferred";
+            deprioritized: "deprioritized";
+            future: "future";
+        }>>;
+    }, z.core.$strip>>>;
+    epic: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ImplementationPlanFrontmatter = z.infer<typeof implementationPlanFrontmatter>;
+/**
+ * Required sections for implementation plans
+ * Note: Disabled - implementation plans have varied structures (phases, tasks, etc.)
+ * that don't fit a strict Problem/Goal/Solution template
+ */
+export declare const implementationPlanSections: readonly [];
+//# sourceMappingURL=implementation-plan.d.ts.map

package/dist/esm/config/docs-lint/schemas/implementation-plan.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { baseFrontmatter, complexity, dateString, implementationStatus } from './common.js';
+/**
+ * Frontmatter schema for implementation plans.
+ * Located in webpresso/blueprints/.
+ */
+export const implementationPlanFrontmatter = baseFrontmatter.extend({
+    type: z.enum(['blueprint']).optional(),
+    /** Plan status: draft, in-progress, complete, archived */
+    status: implementationStatus.optional(),
+    /** Complexity estimate: XS, S, M, L, XL */
+    complexity: complexity.optional(),
+    /** Last update date (optional for incremental adoption) */
+    last_updated: dateString.optional(),
+    /** Dependencies on other plans */
+    depends_on: z.array(z.string()).optional(),
+    /** Cross-repo dependencies on plans in other repos */
+    cross_repo_depends_on: z
+        .array(z.object({
+        repo: z.string(),
+        slug: z.string(),
+        require_status: implementationStatus.optional(),
+    }))
+        .optional(),
+    /** Epic this plan belongs to */
+    epic: z.string().optional(),
+});
+/**
+ * Required sections for implementation plans
+ * Note: Disabled - implementation plans have varied structures (phases, tasks, etc.)
+ * that don't fit a strict Problem/Goal/Solution template
+ */
+export const implementationPlanSections = [];
+//# sourceMappingURL=implementation-plan.js.map

package/dist/esm/config/docs-lint/schemas/index.d.ts

@@ -0,0 +1,51 @@
+import type { ZodSchema } from 'zod';
+export { baseFrontmatter } from './common.js';
+export { decisionFrontmatter } from './decision.js';
+export { implementationPlanFrontmatter, implementationPlanSections } from './implementation-plan.js';
+export type DocType = 'guide' | 'system' | 'research' | 'blueprint' | 'decision' | 'unknown';
+export interface DocTypeConfig {
+    type: DocType;
+    pathPatterns: RegExp[];
+    schema: ZodSchema;
+    requiredSections?: string[];
+}
+export interface ValidationError {
+    file: string;
+    line?: number;
+    column?: number;
+    severity: 'error' | 'warning';
+    source: 'schema' | 'markdownlint' | 'vale' | 'structure' | 'context-limits' | 'blueprint-format';
+    message: string;
+    ruleId?: string;
+}
+/**
+ * Simplified schema registry - only 6 types.
+ * guide, system, research, and unknown all use baseFrontmatter (all fields optional).
+ * Only blueprint and decision have stricter validation.
+ */
+export declare const schemaRegistry: Record<DocType, ZodSchema>;
+/**
+ * Configuration for each doc type including path patterns and required sections.
+ * Simplified to 5 types with broader path matching.
+ */
+export declare const docTypeConfigs: DocTypeConfig[];
+/**
+ * Normalize a type value to a valid DocType.
+ * Returns 'unknown' for unrecognized values.
+ */
+export declare function normalizeDocType(typeValue: string | undefined): DocType;
+/**
+ * Detect doc type from file path.
+ * Returns 'unknown' if no pattern matches.
+ */
+export declare function detectDocType(filePath: string): DocType;
+/**
+ * Get the schema for a doc type.
+ * Falls back to baseFrontmatter for unknown types.
+ */
+export declare function getSchema(docType: DocType): ZodSchema;
+/**
+ * Get the config for a doc type.
+ */
+export declare function getConfig(docType: DocType): DocTypeConfig | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/config/docs-lint/schemas/index.js

@@ -0,0 +1,109 @@
+import { baseFrontmatter } from './common.js';
+import { decisionFrontmatter } from './decision.js';
+import { implementationPlanFrontmatter, implementationPlanSections } from './implementation-plan.js';
+export { baseFrontmatter } from './common.js';
+export { decisionFrontmatter } from './decision.js';
+export { implementationPlanFrontmatter, implementationPlanSections } from './implementation-plan.js';
+const BLUEPRINTS_ROOT = 'webpresso/blueprints';
+/**
+ * Simplified schema registry - only 6 types.
+ * guide, system, research, and unknown all use baseFrontmatter (all fields optional).
+ * Only blueprint and decision have stricter validation.
+ */
+export const schemaRegistry = {
+    guide: baseFrontmatter,
+    system: baseFrontmatter,
+    research: baseFrontmatter,
+    blueprint: implementationPlanFrontmatter,
+    decision: decisionFrontmatter,
+    unknown: baseFrontmatter,
+};
+/**
+ * Configuration for each doc type including path patterns and required sections.
+ * Simplified to 5 types with broader path matching.
+ */
+export const docTypeConfigs = [
+    {
+        type: 'blueprint',
+        pathPatterns: [new RegExp(`^${BLUEPRINTS_ROOT}/`)],
+        schema: implementationPlanFrontmatter,
+        requiredSections: [...implementationPlanSections],
+    },
+    {
+        type: 'decision',
+        pathPatterns: [
+            /^docs\/architecture\/decisions\//,
+            /^docs\/decisions\//,
+            /^docs\/system\/decisions\//,
+        ],
+        schema: decisionFrontmatter,
+    },
+    {
+        type: 'system',
+        pathPatterns: [/^docs\/system\//],
+        schema: baseFrontmatter,
+    },
+    {
+        type: 'research',
+        pathPatterns: [/^docs\/research\//],
+        schema: baseFrontmatter,
+    },
+    {
+        type: 'guide',
+        pathPatterns: [
+            /^docs\//,
+            /^\.agent\/rules\/agent-guide\.md$/,
+            /^AGENTS\.md$/,
+            /^CLAUDE\.md$/,
+            /^GEMINI\.md$/,
+            /^README\.md$/,
+            /README\.md$/,
+            /^\.claude\//,
+        ],
+        schema: baseFrontmatter,
+    },
+];
+/**
+ * Normalize a type value to a valid DocType.
+ * Returns 'unknown' for unrecognized values.
+ */
+export function normalizeDocType(typeValue) {
+    if (!typeValue)
+        return 'unknown';
+    // Check if it's already a valid DocType
+    const validTypes = ['guide', 'system', 'research', 'blueprint', 'decision', 'unknown'];
+    if (validTypes.includes(typeValue)) {
+        return typeValue;
+    }
+    return 'unknown';
+}
+/**
+ * Detect doc type from file path.
+ * Returns 'unknown' if no pattern matches.
+ */
+export function detectDocType(filePath) {
+    // Normalize path separators
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    for (const config of docTypeConfigs) {
+        for (const pattern of config.pathPatterns) {
+            if (pattern.test(normalizedPath)) {
+                return config.type;
+            }
+        }
+    }
+    return 'unknown';
+}
+/**
+ * Get the schema for a doc type.
+ * Falls back to baseFrontmatter for unknown types.
+ */
+export function getSchema(docType) {
+    return schemaRegistry[docType] ?? baseFrontmatter;
+}
+/**
+ * Get the config for a doc type.
+ */
+export function getConfig(docType) {
+    return docTypeConfigs.find((c) => c.type === docType);
+}
+//# sourceMappingURL=index.js.map