@eddacraft/anvil-adapters 0.1.0

package/dist/generic/format-adapter.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Generic Markdown Format Adapter
+ *
+ * FormatAdapter implementation for generic markdown planning documents.
+ * Serves as a fallback adapter for documents that don't match specific formats.
+ */
+import { type APSPlan, type ValidationResult } from '@eddacraft/anvil-core';
+import { BaseFormatAdapter, type AdapterMetadata, type DetectionResult, type ParseResult, type SerializeResult, type ParseContext, type AdapterOptions } from '../base/types.js';
+/**
+ * Generic Markdown FormatAdapter implementation
+ *
+ * Converts between generic markdown documents and APS plans.
+ * Designed to work as a fallback for documents that don't match
+ * specific formats like BMAD or SpecKit.
+ */
+export declare class GenericMarkdownAdapter extends BaseFormatAdapter {
+    readonly metadata: AdapterMetadata;
+    /**
+     * Detect if content is generic markdown planning document
+     *
+     * Uses lower confidence threshold (30-40%) to serve as fallback.
+     * This adapter should be registered last so specific adapters
+     * (BMAD, SpecKit) take precedence.
+     *
+     * @param content - Document content to analyze
+     * @returns Detection result with confidence score
+     */
+    detect(content: string): DetectionResult;
+    /**
+     * Parse generic markdown content to APS plan
+     *
+     * @param content - Markdown content
+     * @param context - Parse context for provenance
+     * @param options - Adapter options
+     * @returns Parse result with APS plan
+     */
+    parse(content: string, context?: ParseContext, _options?: AdapterOptions): Promise<ParseResult>;
+    /**
+     * Serialize APS plan to generic markdown format
+     *
+     * @param plan - APS plan to serialize
+     * @param options - Adapter options
+     * @returns Serialize result with markdown content
+     */
+    serialize(plan: APSPlan, _options?: AdapterOptions): Promise<SerializeResult>;
+    /**
+     * Validate generic markdown content
+     *
+     * Checks for basic markdown structure without strict requirements.
+     *
+     * @param content - Content to validate
+     * @param options - Validation options
+     * @returns Validation result
+     */
+    validate(content: string, _options?: AdapterOptions): Promise<ValidationResult>;
+}
+/**
+ * Create a new generic markdown adapter instance
+ *
+ * @param options - Adapter options
+ * @returns Generic markdown adapter instance
+ */
+export declare function createGenericMarkdownAdapter(options?: AdapterOptions): GenericMarkdownAdapter;
+//# sourceMappingURL=format-adapter.d.ts.map

package/dist/generic/format-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-adapter.d.ts","sourceRoot":"","sources":["../../src/generic/format-adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAgB,KAAK,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC1F,OAAO,EACL,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAC;AAU1B;;;;;;GAMG;AACH,qBAAa,sBAAuB,SAAQ,iBAAiB;IAC3D,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAOhC;IAEF;;;;;;;;;OASG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe;IAcxC;;;;;;;OAOG;IACG,KAAK,CACT,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,YAAY,EACtB,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,WAAW,CAAC;IAwBvB;;;;;;OAMG;IACG,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;IAkBnF;;;;;;;;OAQG;IACG,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAoDtF;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,sBAAsB,CAE7F"}

package/dist/generic/format-adapter.js

@@ -0,0 +1,159 @@
+/**
+ * Generic Markdown Format Adapter
+ *
+ * FormatAdapter implementation for generic markdown planning documents.
+ * Serves as a fallback adapter for documents that don't match specific formats.
+ */
+import { generateHash } from '@eddacraft/anvil-core';
+import { BaseFormatAdapter, } from '../base/types.js';
+import { createDetection } from '../base/utils.js';
+import { analyzeContent, calculateConfidenceScore, buildDetectionReason } from './utils.js';
+import { parseGeneric } from './parser.js';
+import { serializeToGeneric } from './serializer.js';
+const MIN_CONTENT_LENGTH = 50;
+const FALLBACK_DETECTION_THRESHOLD = 30;
+const MAX_FALLBACK_CONFIDENCE = 45;
+/**
+ * Generic Markdown FormatAdapter implementation
+ *
+ * Converts between generic markdown documents and APS plans.
+ * Designed to work as a fallback for documents that don't match
+ * specific formats like BMAD or SpecKit.
+ */
+export class GenericMarkdownAdapter extends BaseFormatAdapter {
+    metadata = {
+        name: 'generic-markdown',
+        version: '1.0.0',
+        displayName: 'Generic Markdown',
+        description: 'Generic markdown adapter for PRDs, plans, todos, and other planning documents',
+        formats: ['generic', 'markdown', 'prd', 'plan', 'todo', 'rfc', 'adr'],
+        extensions: ['.md', '.markdown'],
+    };
+    /**
+     * Detect if content is generic markdown planning document
+     *
+     * Uses lower confidence threshold (30-40%) to serve as fallback.
+     * This adapter should be registered last so specific adapters
+     * (BMAD, SpecKit) take precedence.
+     *
+     * @param content - Document content to analyze
+     * @returns Detection result with confidence score
+     */
+    detect(content) {
+        const indicators = analyzeContent(content);
+        const confidence = calculateConfidenceScore(indicators);
+        const reason = buildDetectionReason(indicators);
+        const cappedConfidence = Math.min(MAX_FALLBACK_CONFIDENCE, confidence);
+        return createDetection(cappedConfidence >= FALLBACK_DETECTION_THRESHOLD, cappedConfidence, reason);
+    }
+    /**
+     * Parse generic markdown content to APS plan
+     *
+     * @param content - Markdown content
+     * @param context - Parse context for provenance
+     * @param options - Adapter options
+     * @returns Parse result with APS plan
+     */
+    async parse(content, context, _options) {
+        try {
+            // Parse content to APS plan
+            const plan = parseGeneric(content, context);
+            // Generate hash for the plan
+            const planWithHash = {
+                ...plan,
+                hash: generateHash(plan),
+            };
+            return this.createParseSuccess(planWithHash);
+        }
+        catch (error) {
+            return this.createParseError([
+                {
+                    code: 'PARSE_ERROR',
+                    message: error instanceof Error ? error.message : 'Failed to parse generic markdown content',
+                    details: error,
+                },
+            ]);
+        }
+    }
+    /**
+     * Serialize APS plan to generic markdown format
+     *
+     * @param plan - APS plan to serialize
+     * @param options - Adapter options
+     * @returns Serialize result with markdown content
+     */
+    async serialize(plan, _options) {
+        try {
+            const content = serializeToGeneric(plan);
+            return this.createSerializeSuccess(content);
+        }
+        catch (error) {
+            return this.createSerializeError([
+                {
+                    code: 'SERIALIZE_ERROR',
+                    message: error instanceof Error
+                        ? error.message
+                        : 'Failed to serialize to generic markdown format',
+                    details: error,
+                },
+            ]);
+        }
+    }
+    /**
+     * Validate generic markdown content
+     *
+     * Checks for basic markdown structure without strict requirements.
+     *
+     * @param content - Content to validate
+     * @param options - Validation options
+     * @returns Validation result
+     */
+    async validate(content, _options) {
+        const issues = [];
+        if (content.trim().length < MIN_CONTENT_LENGTH) {
+            issues.push({
+                code: 'CONTENT_TOO_SHORT',
+                path: 'content',
+                message: 'Content is too short to be a valid planning document',
+                severity: 'error',
+            });
+        }
+        const indicators = analyzeContent(content);
+        const confidence = calculateConfidenceScore(indicators);
+        if (confidence < FALLBACK_DETECTION_THRESHOLD) {
+            issues.push({
+                code: 'LOW_CONFIDENCE',
+                path: 'content',
+                message: `Content does not appear to be a planning document (confidence: ${confidence}%)`,
+                severity: 'error',
+            });
+        }
+        // Warn if missing common planning sections
+        if (!indicators.hasRequirementsSection &&
+            !indicators.hasTasksSection &&
+            !indicators.hasFeaturesSection) {
+            issues.push({
+                code: 'NO_PLANNING_SECTIONS',
+                path: 'content',
+                message: 'Document lacks common planning sections (requirements, tasks, or features)',
+                severity: 'warning',
+            });
+        }
+        return {
+            valid: issues.filter((i) => i.severity === 'error').length === 0,
+            issues: issues.length > 0 ? issues : undefined,
+            summary: issues.length === 0
+                ? 'Generic markdown document is valid'
+                : `Found ${issues.length} validation issue${issues.length > 1 ? 's' : ''}`,
+        };
+    }
+}
+/**
+ * Create a new generic markdown adapter instance
+ *
+ * @param options - Adapter options
+ * @returns Generic markdown adapter instance
+ */
+export function createGenericMarkdownAdapter(options) {
+    return new GenericMarkdownAdapter(options);
+}

package/dist/generic/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generic Markdown Adapter
+ *
+ * Exports for generic markdown format adapter.
+ */
+export { GenericMarkdownAdapter, createGenericMarkdownAdapter } from './format-adapter.js';
+export type { GenericDocument, GenericIndicators } from './types.js';
+export { parseGeneric } from './parser.js';
+export { serializeToGeneric } from './serializer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/generic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generic/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAC3F,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/generic/index.js

@@ -0,0 +1,9 @@
+/**
+ * Generic Markdown Adapter
+ *
+ * Exports for generic markdown format adapter.
+ */
+export { GenericMarkdownAdapter, createGenericMarkdownAdapter } from './format-adapter.js';
+export { parseGeneric } from './parser.js';
+export { serializeToGeneric } from './serializer.js';
+// Note: Utils are not exported to avoid conflicts with BMAD utils

package/dist/generic/parser.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generic Markdown Parser
+ *
+ * Parses generic markdown documents into APS plans.
+ */
+import { type APSPlan } from '@eddacraft/anvil-core';
+import type { ParseContext } from '../base/types.js';
+import type { GenericDocument } from './types.js';
+export declare function genericToAPS(document: GenericDocument, context?: ParseContext, originalContent?: string): APSPlan;
+export declare function parseGeneric(content: string, context?: ParseContext): APSPlan;
+//# sourceMappingURL=parser.d.ts.map

package/dist/generic/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/generic/parser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAqC,MAAM,uBAAuB,CAAC;AACxF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAiDlD,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,eAAe,EACzB,OAAO,CAAC,EAAE,YAAY,EACtB,eAAe,CAAC,EAAE,MAAM,GACvB,OAAO,CA8DT;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAG7E"}

package/dist/generic/parser.js

@@ -0,0 +1,106 @@
+/**
+ * Generic Markdown Parser
+ *
+ * Parses generic markdown documents into APS plans.
+ */
+import { validateRelativePath } from '@eddacraft/anvil-core';
+import { generateDeterministicPlanId } from '../base/utils.js';
+import { parseGenericDocument } from './utils.js';
+/**
+ * Convert generic document item to APS change
+ */
+function itemToChange(item, type) {
+    // Determine change type based on item type
+    let changeType = 'file_create';
+    let pathPrefix = 'src';
+    switch (type) {
+        case 'requirement':
+            changeType = 'file_create';
+            pathPrefix = 'src/features';
+            break;
+        case 'task':
+            changeType = 'file_update';
+            pathPrefix = 'src/tasks';
+            break;
+        case 'feature':
+            changeType = 'file_create';
+            pathPrefix = 'src/features';
+            break;
+    }
+    // Generate a reasonable path from the item description
+    const slug = item
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, '')
+        .replace(/\s+/g, '-')
+        .substring(0, 50);
+    const rawPath = `${pathPrefix}/${slug}.ts`;
+    let safePath;
+    try {
+        safePath = validateRelativePath(rawPath);
+    }
+    catch {
+        safePath = rawPath.replace(/\.{2,}/g, '');
+    }
+    return {
+        type: changeType,
+        path: safePath,
+        description: item,
+    };
+}
+export function genericToAPS(document, context, originalContent) {
+    const planId = context?.planId ??
+        (originalContent
+            ? generateDeterministicPlanId(originalContent)
+            : `aps-${Date.now().toString(16).substring(0, 8)}`);
+    // Collect all changes from requirements, tasks, and features
+    const changes = [];
+    // Add requirements as changes
+    if (document.requirements && document.requirements.length > 0) {
+        changes.push(...document.requirements.map((req) => itemToChange(req, 'requirement')));
+    }
+    // Add tasks as changes
+    if (document.tasks && document.tasks.length > 0) {
+        changes.push(...document.tasks.map((task) => itemToChange(task, 'task')));
+    }
+    // Add features as changes
+    if (document.features && document.features.length > 0) {
+        changes.push(...document.features.map((feat) => itemToChange(feat, 'feature')));
+    }
+    // Build intent from document
+    const intent = document.intent || document.title || document.overview?.substring(0, 200) || 'Generic plan';
+    // Build provenance
+    const timestamp = context?.timestamp || new Date().toISOString();
+    const author = context?.author || 'unknown';
+    // Create APS plan
+    const plan = {
+        id: planId,
+        schema_version: '0.1.0',
+        intent,
+        proposed_changes: changes,
+        provenance: {
+            timestamp,
+            author,
+            source: 'cli',
+            version: '1.0.0',
+            repository: context?.repositoryPath,
+            branch: context?.branch,
+            commit: context?.commit,
+        },
+        validations: {
+            required_checks: ['lint', 'test'],
+            skip_checks: [],
+        },
+        metadata: {
+            source_format: 'generic-markdown',
+            title: document.title,
+            overview: document.overview,
+            goals: document.goals,
+        },
+        hash: '0000000000000000000000000000000000000000000000000000000000000000',
+    };
+    return plan;
+}
+export function parseGeneric(content, context) {
+    const document = parseGenericDocument(content);
+    return genericToAPS(document, context, content);
+}

package/dist/generic/serializer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generic Markdown Serializer
+ *
+ * Serializes APS plans to generic markdown format.
+ */
+import type { APSPlan } from '@eddacraft/anvil-core';
+/**
+ * Serialize APS plan to generic markdown format
+ */
+export declare function serializeToGeneric(plan: APSPlan): string;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/generic/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../src/generic/serializer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAgBrD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CA4GxD"}

package/dist/generic/serializer.js

@@ -0,0 +1,118 @@
+/**
+ * Generic Markdown Serializer
+ *
+ * Serializes APS plans to generic markdown format.
+ */
+/**
+ * Type guard to check if value is a string
+ */
+function isString(value) {
+    return typeof value === 'string';
+}
+/**
+ * Type guard to check if value is a string array
+ */
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+/**
+ * Serialize APS plan to generic markdown format
+ */
+export function serializeToGeneric(plan) {
+    const lines = [];
+    // Title (from intent or metadata) - safely check if title is a non-empty string
+    const metadataTitle = plan.metadata?.['title'];
+    const title = isString(metadataTitle) && metadataTitle ? metadataTitle : plan.intent;
+    lines.push(`# ${title}`);
+    lines.push('');
+    // Overview section - safely check if overview is a string
+    const metadataOverview = plan.metadata?.['overview'];
+    if (metadataOverview && isString(metadataOverview)) {
+        lines.push('## Overview');
+        lines.push('');
+        lines.push(metadataOverview);
+        lines.push('');
+    }
+    else if (plan.intent) {
+        lines.push('## Purpose');
+        lines.push('');
+        lines.push(plan.intent);
+        lines.push('');
+    }
+    // Goals section - safely check if goals is a string array
+    const metadataGoals = plan.metadata?.['goals'];
+    if (metadataGoals && isStringArray(metadataGoals)) {
+        lines.push('## Goals');
+        lines.push('');
+        for (const goal of metadataGoals) {
+            lines.push(`- ${goal}`);
+        }
+        lines.push('');
+    }
+    // Changes section
+    if (plan.proposed_changes.length > 0) {
+        lines.push('## Changes');
+        lines.push('');
+        // Group changes by type
+        const creates = plan.proposed_changes.filter((c) => c.type === 'file_create');
+        const updates = plan.proposed_changes.filter((c) => c.type === 'file_update');
+        const deletes = plan.proposed_changes.filter((c) => c.type === 'file_delete');
+        const configs = plan.proposed_changes.filter((c) => c.type === 'config_update');
+        if (creates.length > 0) {
+            lines.push('### Files to Create');
+            lines.push('');
+            for (const change of creates) {
+                lines.push(`- **${change.path}**: ${change.description}`);
+            }
+            lines.push('');
+        }
+        if (updates.length > 0) {
+            lines.push('### Files to Update');
+            lines.push('');
+            for (const change of updates) {
+                lines.push(`- **${change.path}**: ${change.description}`);
+            }
+            lines.push('');
+        }
+        if (configs.length > 0) {
+            lines.push('### Configuration Changes');
+            lines.push('');
+            for (const change of configs) {
+                lines.push(`- **${change.path}**: ${change.description}`);
+            }
+            lines.push('');
+        }
+        if (deletes.length > 0) {
+            lines.push('### Files to Delete');
+            lines.push('');
+            for (const change of deletes) {
+                lines.push(`- **${change.path}**: ${change.description}`);
+            }
+            lines.push('');
+        }
+    }
+    // Validation requirements
+    if (plan.validations.required_checks.length > 0) {
+        lines.push('## Validation Requirements');
+        lines.push('');
+        for (const check of plan.validations.required_checks) {
+            lines.push(`- ${check}`);
+        }
+        lines.push('');
+    }
+    // Metadata section
+    if (plan.provenance) {
+        lines.push('## Metadata');
+        lines.push('');
+        lines.push(`- **Author**: ${plan.provenance.author || 'Unknown'}`);
+        lines.push(`- **Created**: ${plan.provenance.timestamp}`);
+        if (plan.provenance.repository) {
+            lines.push(`- **Repository**: ${plan.provenance.repository}`);
+        }
+        if (plan.provenance.branch) {
+            lines.push(`- **Branch**: ${plan.provenance.branch}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}

package/dist/generic/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Generic Adapter Types
+ *
+ * Types for the generic markdown adapter that handles common planning document formats.
+ */
+/**
+ * Parsed generic document structure
+ */
+export interface GenericDocument {
+    /** Document title (from first # heading) */
+    title?: string;
+    /** Intent/purpose extracted from intro or objective sections */
+    intent?: string;
+    /** Overview/description */
+    overview?: string;
+    /** Goals or objectives */
+    goals?: string[];
+    /** Requirements extracted from various sections */
+    requirements?: string[];
+    /** Tasks or action items */
+    tasks?: string[];
+    /** Features or capabilities */
+    features?: string[];
+    /** Metadata from document */
+    metadata?: Record<string, unknown>;
+    /** Raw content */
+    raw: string;
+}
+/**
+ * Detection indicators for generic markdown
+ */
+export interface GenericIndicators {
+    /** Has markdown headings */
+    hasHeadings: boolean;
+    /** Has lists (bullet or numbered) */
+    hasLists: boolean;
+    /** Has requirements-like content */
+    hasRequirementsSection: boolean;
+    /** Has goals/objectives section */
+    hasGoalsSection: boolean;
+    /** Has tasks/action items */
+    hasTasksSection: boolean;
+    /** Has features section */
+    hasFeaturesSection: boolean;
+    /** Has overview/description */
+    hasOverviewSection: boolean;
+    /** Document length */
+    wordCount: number;
+    /** Number of list items */
+    listItemCount: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/generic/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/generic/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0BAA0B;IAC1B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,mDAAmD;IACnD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,4BAA4B;IAC5B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,kBAAkB;IAClB,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,4BAA4B;IAC5B,WAAW,EAAE,OAAO,CAAC;IACrB,qCAAqC;IACrC,QAAQ,EAAE,OAAO,CAAC;IAClB,oCAAoC;IACpC,sBAAsB,EAAE,OAAO,CAAC;IAChC,mCAAmC;IACnC,eAAe,EAAE,OAAO,CAAC;IACzB,6BAA6B;IAC7B,eAAe,EAAE,OAAO,CAAC;IACzB,2BAA2B;IAC3B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,+BAA+B;IAC/B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,sBAAsB;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,2BAA2B;IAC3B,aAAa,EAAE,MAAM,CAAC;CACvB"}

package/dist/generic/types.js

@@ -0,0 +1,6 @@
+/**
+ * Generic Adapter Types
+ *
+ * Types for the generic markdown adapter that handles common planning document formats.
+ */
+export {};

package/dist/generic/utils.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Generic Adapter Utilities
+ *
+ * Helper functions for parsing generic markdown documents.
+ */
+import type { GenericDocument, GenericIndicators } from './types.js';
+/**
+ * Extract document title from first heading
+ */
+export declare function extractTitle(content: string): string | undefined;
+/**
+ * Extract intent from common sections
+ */
+export declare function extractIntent(content: string): string | undefined;
+/**
+ * Extract overview/description
+ */
+export declare function extractOverview(content: string): string | undefined;
+/**
+ * Extract goals from lists under Goals/Objectives sections
+ */
+export declare function extractGoals(content: string): string[];
+/**
+ * Extract requirements from various sections
+ */
+export declare function extractRequirements(content: string): string[];
+/**
+ * Extract tasks from Tasks/Action Items sections
+ */
+export declare function extractTasks(content: string): string[];
+/**
+ * Extract features from Features/Capabilities sections
+ */
+export declare function extractFeatures(content: string): string[];
+/**
+ * Analyze content for generic markdown indicators
+ */
+export declare function analyzeContent(content: string): GenericIndicators;
+/**
+ * Calculate confidence score for generic markdown detection
+ */
+export declare function calculateConfidenceScore(indicators: GenericIndicators): number;
+/**
+ * Build detection reason string
+ */
+export declare function buildDetectionReason(indicators: GenericIndicators): string;
+/**
+ * Parse generic markdown document
+ */
+export declare function parseGenericDocument(content: string): GenericDocument;
+//# sourceMappingURL=utils.d.ts.map

package/dist/generic/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/generic/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAErE;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGhE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAgBjE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAWnE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAgBtD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CA2B7D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBtD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBzD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAgBjE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM,CA+C9E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM,CA0B1E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAWrE"}