@libar-dev/architect 1.0.0-pre.3

package/dist/validation-schemas/config.d.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import type { RegistryFilePath } from '../types/branded.js';
+/**
+ * Scanner configuration
+ *
+ * Schema enforces:
+ * - At least one glob pattern
+ * - No parent directory traversal in patterns
+ * - Normalized base directory path
+ * - Strict mode to prevent extra fields
+ *
+ * **Transform Chain:**
+ * 1. Validate pattern non-empty
+ * 2. Check for security issues (..)
+ * 3. Normalize baseDir to absolute path
+ */
+export declare const ScannerConfigSchema: z.ZodObject<{
+    patterns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    baseDir: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+}, z.core.$strict>;
+/**
+ * Type alias inferred from schema
+ *
+ * **Schema-First Law**: Type automatically derives from Zod schema.
+ */
+export type ScannerConfig = z.infer<typeof ScannerConfigSchema>;
+/**
+ * Generator configuration type
+ *
+ * **Note**: Defined explicitly to break circular dependency with factory function
+ * while maintaining type safety and TIER 1 compliance.
+ */
+export interface GeneratorConfig {
+    outputDir: string;
+    registryPath: RegistryFilePath;
+    overwrite: boolean;
+    readmeOnly: boolean;
+}
+/**
+ * Generator configuration factory
+ *
+ * **Security**: Requires explicit baseDir to prevent path manipulation attacks.
+ *
+ * Schema enforces:
+ * - Output directory within explicit baseDir (security)
+ * - Registry file is JSON format
+ * - Path normalization with symlink prevention
+ * - Strict mode to prevent extra fields
+ *
+ * **Transform Chain:**
+ * 1. Normalize output directory to absolute path
+ * 2. Validate within explicit baseDir boundaries
+ * 3. Prevent parent directory traversal (..)
+ * 4. Ensure registry is .json file
+ * 5. Normalize all paths
+ *
+ * @param baseDir - Explicit base directory for security validation
+ * @returns Generator config schema
+ *
+ * @example
+ * ```typescript
+ * const schema = createGeneratorConfigSchema(process.cwd());
+ * const config = schema.parse({
+ *   outputDir: 'docs',
+ *   registryPath: 'registry.json'
+ * });
+ * ```
+ */
+export declare function createGeneratorConfigSchema(baseDir: string): z.ZodType<GeneratorConfig>;
+/**
+ * Runtime type guard for ScannerConfig
+ *
+ * @param value - Value to check
+ * @returns True if value conforms to ScannerConfig schema
+ *
+ * @example
+ * ```typescript
+ * if (isScannerConfig(parsed)) {
+ *   console.log(parsed.patterns); // Type-safe access
+ * }
+ * ```
+ */
+export declare function isScannerConfig(value: unknown): value is ScannerConfig;
+/**
+ * Runtime type guard for GeneratorConfig
+ *
+ * @param value - Value to check
+ * @returns True if value conforms to GeneratorConfig schema
+ *
+ * @example
+ * ```typescript
+ * if (isGeneratorConfig(parsed)) {
+ *   console.log(parsed.outputDir); // Type-safe access
+ * }
+ * ```
+ */
+export declare function isGeneratorConfig(value: unknown): value is GeneratorConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/validation-schemas/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/validation-schemas/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAoF5D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB;;;;kBAWrB,CAAC;AAEZ;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,gBAAgB,CAAC;IAC/B,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC,CAgBvF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAG1E"}

package/dist/validation-schemas/config.js

@@ -0,0 +1,178 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { z } from 'zod';
+import { asRegistryFilePath } from '../types/branded.js';
+/**
+ * Safely resolve a path, following symlinks if possible
+ *
+ * Falls back to path.resolve if the path doesn't exist yet
+ * (which is valid for output directories that will be created)
+ */
+function safeRealpathSync(filePath) {
+    try {
+        return fs.realpathSync(filePath);
+    }
+    catch {
+        // Path doesn't exist yet, use regular resolve
+        return path.resolve(filePath);
+    }
+}
+/**
+ * Glob pattern validation
+ * Must be non-empty and not contain parent directory traversal for security
+ */
+const GlobPatternSchema = z
+    .string()
+    .min(1, 'Glob pattern cannot be empty')
+    .refine((pattern) => !pattern.includes('..'), {
+    message: 'Glob patterns cannot contain parent directory traversal (..)',
+});
+/**
+ * Base directory validation with normalization
+ */
+const BaseDirSchema = z
+    .string()
+    .min(1, 'Base directory cannot be empty')
+    .transform((dir) => path.resolve(dir)); // Normalize to absolute path
+/**
+ * Create output directory validator with explicit base directory
+ *
+ * **Security**: Uses explicit baseDir parameter instead of process.cwd()
+ * to prevent manipulation via symlinks or environment changes.
+ *
+ * @param baseDir - Explicit base directory for validation
+ * @returns Output directory schema validator
+ *
+ */
+function createOutputDirSchema(baseDir) {
+    return z
+        .string()
+        .min(1, 'Output directory cannot be empty')
+        .transform((dir) => path.normalize(path.resolve(dir)))
+        .refine((dir) => {
+        // Resolve symlinks for the base directory to prevent bypass attacks
+        const resolvedBase = safeRealpathSync(baseDir);
+        const resolvedDir = safeRealpathSync(dir);
+        // Prevent parent directory traversal
+        if (dir.includes('..')) {
+            return false;
+        }
+        // Must be within resolvedBase or be a relative path
+        return resolvedDir.startsWith(resolvedBase) || !path.isAbsolute(dir);
+    }, {
+        message: 'Output directory must be within project (no parent traversal)',
+    });
+}
+/**
+ * Registry file path validation
+ * Must be a JSON file
+ */
+const RegistryFilePathSchema = z
+    .string()
+    .min(1, 'Registry path cannot be empty')
+    .refine((p) => p.endsWith('.json'), {
+    message: 'Registry file must be a JSON file (.json)',
+})
+    .transform((p) => asRegistryFilePath(path.normalize(p)));
+/**
+ * Scanner configuration
+ *
+ * Schema enforces:
+ * - At least one glob pattern
+ * - No parent directory traversal in patterns
+ * - Normalized base directory path
+ * - Strict mode to prevent extra fields
+ *
+ * **Transform Chain:**
+ * 1. Validate pattern non-empty
+ * 2. Check for security issues (..)
+ * 3. Normalize baseDir to absolute path
+ */
+export const ScannerConfigSchema = z
+    .object({
+    /** Glob patterns to scan (e.g., 'src/**\/*.ts') */
+    patterns: z.array(GlobPatternSchema).min(1, 'At least one glob pattern required').readonly(),
+    /** Directories to exclude (optional) */
+    exclude: z.array(GlobPatternSchema).readonly().optional(),
+    /** Base directory for scanning (normalized to absolute path) */
+    baseDir: BaseDirSchema,
+})
+    .strict();
+/**
+ * Generator configuration factory
+ *
+ * **Security**: Requires explicit baseDir to prevent path manipulation attacks.
+ *
+ * Schema enforces:
+ * - Output directory within explicit baseDir (security)
+ * - Registry file is JSON format
+ * - Path normalization with symlink prevention
+ * - Strict mode to prevent extra fields
+ *
+ * **Transform Chain:**
+ * 1. Normalize output directory to absolute path
+ * 2. Validate within explicit baseDir boundaries
+ * 3. Prevent parent directory traversal (..)
+ * 4. Ensure registry is .json file
+ * 5. Normalize all paths
+ *
+ * @param baseDir - Explicit base directory for security validation
+ * @returns Generator config schema
+ *
+ * @example
+ * ```typescript
+ * const schema = createGeneratorConfigSchema(process.cwd());
+ * const config = schema.parse({
+ *   outputDir: 'docs',
+ *   registryPath: 'registry.json'
+ * });
+ * ```
+ */
+export function createGeneratorConfigSchema(baseDir) {
+    return z
+        .object({
+        /** Output directory for generated docs (within baseDir) */
+        outputDir: createOutputDirSchema(baseDir),
+        /** Registry file path (must be .json) */
+        registryPath: RegistryFilePathSchema,
+        /** Whether to overwrite existing files */
+        overwrite: z.boolean().default(false),
+        /** When true, only generate OVERVIEW.md, DECISIONS.md, and registry.json */
+        readmeOnly: z.boolean().default(false),
+    })
+        .strict();
+}
+/**
+ * Runtime type guard for ScannerConfig
+ *
+ * @param value - Value to check
+ * @returns True if value conforms to ScannerConfig schema
+ *
+ * @example
+ * ```typescript
+ * if (isScannerConfig(parsed)) {
+ *   console.log(parsed.patterns); // Type-safe access
+ * }
+ * ```
+ */
+export function isScannerConfig(value) {
+    return ScannerConfigSchema.safeParse(value).success;
+}
+/**
+ * Runtime type guard for GeneratorConfig
+ *
+ * @param value - Value to check
+ * @returns True if value conforms to GeneratorConfig schema
+ *
+ * @example
+ * ```typescript
+ * if (isGeneratorConfig(parsed)) {
+ *   console.log(parsed.outputDir); // Type-safe access
+ * }
+ * ```
+ */
+export function isGeneratorConfig(value) {
+    const schema = createGeneratorConfigSchema(process.cwd());
+    return schema.safeParse(value).success;
+}
+//# sourceMappingURL=config.js.map

package/dist/validation-schemas/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/validation-schemas/config.ts"],"names":[],"mappings":"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"}

package/dist/validation-schemas/doc-directive.d.ts

@@ -0,0 +1,195 @@
+/**
+ * @architect
+ * @architect-validation
+ * @architect-pattern DocDirectiveSchema
+ * @architect-status completed
+ * @architect-implements MvpWorkflowImplementation
+ * @architect-used-by DocExtractor, ExtractedPatternSchema
+ *
+ * ## DocDirectiveSchema - Parsed JSDoc Directive Validation
+ *
+ * Zod schemas for validating parsed @architect-* directives from JSDoc comments.
+ * Enforces tag format, position validity, and metadata extraction.
+ *
+ * ### When to Use
+ *
+ * - Use when parsing JSDoc comments for @architect-* tags
+ * - Use when validating directive structure at boundaries
+ */
+import { z } from 'zod';
+import { type ProcessStatusValue } from '../taxonomy/index.js';
+import type { TagRegistry } from './tag-registry.js';
+/**
+ * Position information for a directive in source code
+ */
+export declare const PositionSchema: z.ZodObject<{
+    startLine: z.ZodNumber;
+    endLine: z.ZodNumber;
+}, z.core.$strict>;
+export type Position = z.infer<typeof PositionSchema>;
+/**
+ * Creates a DirectiveTag schema for a given tag prefix.
+ * This factory enables projects to use custom prefixes (e.g., "@acme-" instead of "@architect-").
+ *
+ * @param tagPrefix - The tag prefix to validate against (e.g., "@acme-" or "@architect-")
+ * @returns Zod schema that validates and transforms tags with the given prefix
+ *
+ * @example
+ * ```typescript
+ * // Custom prefix
+ * const customSchema = createDirectiveTagSchema("@acme-");
+ * customSchema.parse("@acme-pattern"); // Valid
+ *
+ * // Default prefix
+ * const defaultSchema = createDirectiveTagSchema("@architect-");
+ * defaultSchema.parse("@architect-status"); // Valid
+ * ```
+ */
+export declare function createDirectiveTagSchema(tagPrefix: string): z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").DirectiveTag, string>>;
+/**
+ * Default status values for pattern implementation state
+ *
+ * Uses the single source of truth from taxonomy module (PDR-005 FSM).
+ * For registry-based status validation, use createPatternStatusSchema().
+ *
+ * @see src/taxonomy/status-values.ts
+ */
+export declare const DefaultPatternStatusSchema: z.ZodEnum<{
+    roadmap: "roadmap";
+    active: "active";
+    completed: "completed";
+    deferred: "deferred";
+}>;
+/**
+ * Status values accepted for directive validation
+ *
+ * @see src/taxonomy/status-values.ts
+ */
+export declare const AcceptedPatternStatusSchema: z.ZodEnum<{
+    roadmap: "roadmap";
+    active: "active";
+    completed: "completed";
+    deferred: "deferred";
+}>;
+/**
+ * Pattern status schema for directive validation
+ *
+ * Accepts canonical PDR-005 FSM states only.
+ */
+export declare const PatternStatusSchema: z.ZodEnum<{
+    roadmap: "roadmap";
+    active: "active";
+    completed: "completed";
+    deferred: "deferred";
+}>;
+export type PatternStatus = ProcessStatusValue;
+/**
+ * Create pattern status schema from tag registry
+ *
+ * Builds a Zod enum schema using status values defined in the registry's
+ * metadata tags. Falls back to default schema if "status" tag not found in registry.
+ *
+ * @param registry - Tag registry containing metadata tag definitions
+ * @returns Zod enum schema for pattern status validation
+ *
+ * @example
+ * ```typescript
+ * const config = await loadConfig();
+ * const statusSchema = createPatternStatusSchema(config.tagRegistry);
+ * const result = statusSchema.safeParse("completed"); // Validates against registry values
+ * ```
+ */
+export declare function createPatternStatusSchema(registry: TagRegistry): z.ZodType<string>;
+/**
+ * Parsed @architect-* directive from JSDoc comment
+ *
+ * Schema enforces:
+ * - At least one tag
+ * - Valid position with endLine >= startLine
+ * - Strict mode to prevent extra fields
+ *
+ * Description defaults to empty string to allow tag-only directives:
+ * ```typescript
+ * /**
+ *  * @architect-core
+ *  *\/
+ * export function myFunction() {}
+ * ```
+ */
+export declare const DocDirectiveSchema: z.ZodObject<{
+    tags: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").DirectiveTag, string>>>>;
+    description: z.ZodDefault<z.ZodString>;
+    examples: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    position: z.ZodObject<{
+        startLine: z.ZodNumber;
+        endLine: z.ZodNumber;
+    }, z.core.$strict>;
+    patternName: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        roadmap: "roadmap";
+        active: "active";
+        completed: "completed";
+        deferred: "deferred";
+    }>>;
+    isCore: z.ZodOptional<z.ZodBoolean>;
+    useCases: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    whenToUse: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    uses: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    usedBy: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    phase: z.ZodOptional<z.ZodNumber>;
+    brief: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    enables: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    implements: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    extends: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    apiRef: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    quarter: z.ZodOptional<z.ZodString>;
+    completed: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodString>;
+    effortActual: z.ZodOptional<z.ZodString>;
+    team: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodOptional<z.ZodString>;
+    risk: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+    archRole: z.ZodOptional<z.ZodString>;
+    archContext: z.ZodOptional<z.ZodString>;
+    archLayer: z.ZodOptional<z.ZodString>;
+    include: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    productArea: z.ZodOptional<z.ZodString>;
+    extractShapes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    convention: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    claudeModule: z.ZodOptional<z.ZodString>;
+    claudeSection: z.ZodOptional<z.ZodEnum<{
+        infrastructure: "infrastructure";
+        testing: "testing";
+        core: "core";
+        workflow: "workflow";
+        process: "process";
+    }>>;
+    claudeTags: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>;
+/**
+ * Type alias inferred from schema
+ *
+ * **Schema-First Law**: Always infer types from schemas,
+ * never define types separately to avoid duplication.
+ */
+export type DocDirective = z.infer<typeof DocDirectiveSchema>;
+/**
+ * Runtime type guard for DocDirective
+ *
+ * @param value - Value to check
+ * @returns True if value conforms to DocDirective schema
+ *
+ * @example
+ * ```typescript
+ * if (isDocDirective(parsed)) {
+ *   console.log(parsed.tags); // Type-safe access
+ * }
+ * ```
+ */
+export declare function isDocDirective(value: unknown): value is DocDirective;
+//# sourceMappingURL=doc-directive.d.ts.map

package/dist/validation-schemas/doc-directive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-directive.d.ts","sourceRoot":"","sources":["../../src/validation-schemas/doc-directive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD;;GAEG;AACH,eAAO,MAAM,cAAc;;;kBAWvB,CAAC;AAEL,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AAEH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,sFAQzD;AAUD;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B;;;;;EAAgC,CAAC;AAExE;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;;;EAAiC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;EAAgC,CAAC;AACjE,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC;AAE/C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,WAAW,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAalF;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+HpB,CAAC;AAEZ;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE"}