@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/testing/generators/use-case-parser.js

@@ -0,0 +1,325 @@
+/**
+ * UseCaseParser - Parse use case documents to extract testable scenarios
+ *
+ * Parses use case markdown documents following the standard template format
+ * and extracts structured test scenarios for test generation.
+ *
+ * @module src/testing/generators/use-case-parser
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// ===========================
+// UseCaseParser Class
+// ===========================
+export class UseCaseParser {
+    MAIN_SCENARIO_PATTERN = /^#+\s*(Main\s+)?Success\s+Scenario/im;
+    EXTENSION_PATTERN = /^#+\s*Extensions?/im;
+    EXCEPTION_PATTERN = /^#+\s*Exception(s|\s+Scenario)/im;
+    STEP_PATTERN = /^\s*(\d+)\.\s+(?:\*\*(\w+)\*\*:?\s+)?(.+)/;
+    PRECONDITION_PATTERN = /^#+\s*Pre-?conditions?/im;
+    POSTCONDITION_PATTERN = /^#+\s*Post-?conditions?/im;
+    NFR_REF_PATTERN = /NFR-[A-Z]+-\d+/g;
+    UC_REF_PATTERN = /UC-\d+/g;
+    /**
+     * Parse a use case document from file
+     *
+     * @param filePath - Path to use case markdown file
+     * @returns Parse result with structured document
+     */
+    async parseFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            return this.parseContent(content, path.basename(filePath));
+        }
+        catch (error) {
+            return {
+                success: false,
+                errors: [`Failed to read file: ${error.message}`],
+                warnings: []
+            };
+        }
+    }
+    /**
+     * Parse use case content from string
+     *
+     * @param content - Markdown content
+     * @param sourceName - Source identifier for error messages
+     * @returns Parse result with structured document
+     */
+    parseContent(content, sourceName = 'input') {
+        const errors = [];
+        const warnings = [];
+        // Extract use case ID from content
+        const idMatch = content.match(/UC-(\d+)/);
+        const id = idMatch ? `UC-${idMatch[1]}` : this.extractIdFromFilename(sourceName);
+        if (!id) {
+            errors.push('Could not determine use case ID');
+        }
+        // Extract title from first heading
+        const titleMatch = content.match(/^#\s+(.+)/m);
+        const title = titleMatch ? titleMatch[1].trim() : 'Unknown Use Case';
+        // Extract actor
+        const actorMatch = content.match(/\*\*(?:Primary\s+)?Actor\*\*:\s*(.+)/i) ||
+            content.match(/Actor:\s*(.+)/i);
+        const actor = actorMatch ? actorMatch[1].trim() : 'User';
+        // Extract description
+        const descMatch = content.match(/\*\*Description\*\*:\s*(.+)/i) ||
+            content.match(/^>\s*(.+)/m);
+        const description = descMatch ? descMatch[1].trim() : '';
+        // Extract priority
+        const priorityMatch = content.match(/\*\*Priority\*\*:\s*(\w+)/i);
+        const priority = this.normalizePriority(priorityMatch?.[1] || 'medium');
+        // Parse preconditions
+        const preconditions = this.parseBulletList(content, this.PRECONDITION_PATTERN);
+        // Parse postconditions
+        const postconditions = this.parseBulletList(content, this.POSTCONDITION_PATTERN);
+        // Parse main scenario
+        const mainScenario = this.parseMainScenario(content, id || 'UC-000');
+        if (!mainScenario) {
+            warnings.push('No main success scenario found');
+        }
+        // Parse extensions
+        const extensions = this.parseExtensions(content, id || 'UC-000');
+        // Parse exceptions
+        const exceptions = this.parseExceptions(content, id || 'UC-000');
+        // Extract NFR references
+        const nfrs = this.extractReferences(content, this.NFR_REF_PATTERN);
+        // Extract related use cases
+        const relatedUseCases = this.extractReferences(content, this.UC_REF_PATTERN)
+            .filter(ref => ref !== id);
+        if (errors.length > 0) {
+            return { success: false, errors, warnings };
+        }
+        return {
+            success: true,
+            document: {
+                id: id,
+                title,
+                actor,
+                description,
+                preconditions,
+                postconditions,
+                mainScenario: mainScenario || this.createEmptyScenario(id, 'main'),
+                extensions,
+                exceptions,
+                nfrs,
+                relatedUseCases,
+                priority
+            },
+            errors: [],
+            warnings
+        };
+    }
+    /**
+     * Parse multiple use case files from a directory
+     *
+     * @param dirPath - Directory containing use case files
+     * @returns Array of parse results
+     */
+    async parseDirectory(dirPath) {
+        const results = new Map();
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile() && entry.name.match(/UC-\d+.*\.md$/i)) {
+                    const filePath = path.join(dirPath, entry.name);
+                    const result = await this.parseFile(filePath);
+                    results.set(entry.name, result);
+                }
+            }
+        }
+        catch (error) {
+            // Return empty map if directory doesn't exist
+        }
+        return results;
+    }
+    /**
+     * Extract testable scenarios from a use case document
+     *
+     * @param document - Parsed use case document
+     * @returns Array of all testable scenarios
+     */
+    extractTestableScenarios(document) {
+        const scenarios = [];
+        // Add main scenario
+        scenarios.push(document.mainScenario);
+        // Add extensions
+        scenarios.push(...document.extensions);
+        // Add exceptions
+        scenarios.push(...document.exceptions);
+        return scenarios;
+    }
+    // ===========================
+    // Private Parsing Methods
+    // ===========================
+    parseMainScenario(content, useCaseId) {
+        const match = content.match(this.MAIN_SCENARIO_PATTERN);
+        if (!match)
+            return null;
+        const sectionStart = match.index + match[0].length;
+        const sectionContent = this.extractSectionContent(content, sectionStart);
+        const steps = this.parseSteps(sectionContent);
+        return {
+            id: `${useCaseId}-MSS`,
+            name: 'Main Success Scenario',
+            type: 'main',
+            preconditions: [],
+            steps,
+            postconditions: []
+        };
+    }
+    parseExtensions(content, useCaseId) {
+        const extensions = [];
+        const match = content.match(this.EXTENSION_PATTERN);
+        if (!match)
+            return extensions;
+        const sectionStart = match.index + match[0].length;
+        const sectionContent = this.extractSectionContent(content, sectionStart);
+        // Parse extension scenarios (e.g., "2a. User cancels...")
+        const extensionPattern = /(\d+)([a-z])\.\s+(.+?)(?=\n\d+[a-z]\.|\n#+|\n\n\n|$)/gs;
+        let extMatch;
+        while ((extMatch = extensionPattern.exec(sectionContent)) !== null) {
+            const stepNum = parseInt(extMatch[1]);
+            const extId = extMatch[2];
+            const extContent = extMatch[3].trim();
+            // Parse extension steps
+            const extSteps = this.parseExtensionSteps(extContent);
+            extensions.push({
+                id: `${useCaseId}-EXT-${stepNum}${extId.toUpperCase()}`,
+                name: `Extension at step ${stepNum}`,
+                type: 'extension',
+                preconditions: [],
+                steps: extSteps,
+                postconditions: [],
+                extensionOf: `${useCaseId}-MSS`,
+                triggeredAt: stepNum
+            });
+        }
+        return extensions;
+    }
+    parseExceptions(content, useCaseId) {
+        const exceptions = [];
+        const match = content.match(this.EXCEPTION_PATTERN);
+        if (!match)
+            return exceptions;
+        const sectionStart = match.index + match[0].length;
+        const sectionContent = this.extractSectionContent(content, sectionStart);
+        // Parse exception scenarios
+        const exceptionPattern = /\*\*([^*]+)\*\*:\s*(.+?)(?=\n\*\*|\n#+|\n\n\n|$)/gs;
+        let exMatch;
+        let counter = 1;
+        while ((exMatch = exceptionPattern.exec(sectionContent)) !== null) {
+            const name = exMatch[1].trim();
+            const description = exMatch[2].trim();
+            exceptions.push({
+                id: `${useCaseId}-EXC-${String(counter).padStart(2, '0')}`,
+                name,
+                type: 'exception',
+                preconditions: [],
+                steps: [{
+                        number: 1,
+                        actor: 'system',
+                        action: description
+                    }],
+                postconditions: []
+            });
+            counter++;
+        }
+        return exceptions;
+    }
+    parseSteps(content) {
+        const steps = [];
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const match = line.match(this.STEP_PATTERN);
+            if (match) {
+                const number = parseInt(match[1]);
+                const actorHint = match[2]?.toLowerCase() || '';
+                const action = match[3].trim();
+                let actor = 'system';
+                if (actorHint.includes('user') || action.toLowerCase().startsWith('user')) {
+                    actor = 'user';
+                }
+                else if (actorHint.includes('external') || action.toLowerCase().includes('external')) {
+                    actor = 'external';
+                }
+                steps.push({ number, actor, action });
+            }
+        }
+        return steps;
+    }
+    parseExtensionSteps(content) {
+        const steps = [];
+        const lines = content.split('\n');
+        let stepNum = 1;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#')) {
+                // Determine actor from content
+                let actor = 'system';
+                if (trimmed.toLowerCase().includes('user')) {
+                    actor = 'user';
+                }
+                steps.push({
+                    number: stepNum++,
+                    actor,
+                    action: trimmed
+                });
+            }
+        }
+        return steps;
+    }
+    parseBulletList(content, sectionPattern) {
+        const items = [];
+        const match = content.match(sectionPattern);
+        if (!match)
+            return items;
+        const sectionStart = match.index + match[0].length;
+        const sectionContent = this.extractSectionContent(content, sectionStart);
+        // Parse bullet points
+        const bulletPattern = /^\s*[-*]\s+(.+)/gm;
+        let bulletMatch;
+        while ((bulletMatch = bulletPattern.exec(sectionContent)) !== null) {
+            items.push(bulletMatch[1].trim());
+        }
+        return items;
+    }
+    extractSectionContent(content, startIndex) {
+        // Find next heading or end of content
+        const remaining = content.substring(startIndex);
+        const nextHeading = remaining.search(/\n#+\s/);
+        if (nextHeading === -1) {
+            return remaining;
+        }
+        return remaining.substring(0, nextHeading);
+    }
+    extractReferences(content, pattern) {
+        const matches = content.match(pattern) || [];
+        return [...new Set(matches)]; // Deduplicate
+    }
+    extractIdFromFilename(filename) {
+        const match = filename.match(/UC-(\d+)/i);
+        return match ? `UC-${match[1]}` : null;
+    }
+    normalizePriority(priority) {
+        const lower = priority.toLowerCase();
+        if (lower.includes('critical') || lower === 'p0')
+            return 'critical';
+        if (lower.includes('high') || lower === 'p1')
+            return 'high';
+        if (lower.includes('low') || lower === 'p3')
+            return 'low';
+        return 'medium';
+    }
+    createEmptyScenario(useCaseId, type) {
+        return {
+            id: `${useCaseId}-${type.toUpperCase()}`,
+            name: `Empty ${type} scenario`,
+            type,
+            preconditions: [],
+            steps: [],
+            postconditions: []
+        };
+    }
+}
+//# sourceMappingURL=use-case-parser.js.map

package/dist/src/testing/index.js

@@ -0,0 +1,11 @@
+/**
+ * Testing Module
+ *
+ * Comprehensive test infrastructure including generators, fixtures, and corpus management.
+ *
+ * @module src/testing
+ */
+export * from './generators/index.js';
+export * from './fixtures/index.js';
+export * from './corpus/index.js';
+//# sourceMappingURL=index.js.map

package/dist/src/tracker/capability-protocol.js

@@ -0,0 +1,118 @@
+/**
+ * Canonical tracker authority and access-path selection.
+ *
+ * Tracker-sensitive work must resolve authority from `.aiwg/aiwg.config`
+ * before considering whichever CLI happens to be authenticated. This module is
+ * deliberately pure so skills, context generation, and tests can all share the
+ * same authority model.
+ *
+ * @implements #1734
+ * @implements #1735
+ */
+import { resolveRemoteProvider, resolveRemotes, } from '../config/aiwg-config.js';
+function providerFromIssueStorage(issueStorage) {
+    const value = issueStorage?.toLowerCase() ?? '';
+    if (!value)
+        return 'unknown';
+    if (value.includes('local'))
+        return 'local';
+    if (value.includes('gitea'))
+        return 'gitea';
+    if (value.includes('github'))
+        return 'github';
+    if (value.includes('gitlab'))
+        return 'gitlab';
+    return 'unknown';
+}
+function normalizeProvider(provider) {
+    return provider === 'gitea' || provider === 'github' || provider === 'gitlab'
+        ? provider
+        : 'unknown';
+}
+function providerMatches(probe, authority) {
+    if (authority.provider === 'unknown') {
+        return probe.remoteName === authority.issueTrackerRemote || probe.provider === undefined;
+    }
+    return probe.provider === authority.provider || probe.remoteName === authority.issueTrackerRemote;
+}
+function probeIsUsable(probe, authority) {
+    return probe.available === true && probe.authenticated !== false && providerMatches(probe, authority);
+}
+function accessLabel(probe) {
+    if (probe.label)
+        return probe.label;
+    if (probe.kind === 'cli' && probe.cli)
+        return `${probe.cli} CLI`;
+    if (probe.kind === 'http-api')
+        return 'tracker HTTP API';
+    return 'MCP/app tools';
+}
+export function resolveTrackerAuthority(config, remoteUrls = {}, configPath = '.aiwg/aiwg.config') {
+    const remotes = resolveRemotes(config?.remotes);
+    const issueStorage = config?.delivery?.issue_storage;
+    const issueTrackerUrl = remoteUrls[remotes.issue_tracker];
+    const storageProvider = providerFromIssueStorage(issueStorage);
+    const urlProvider = issueTrackerUrl ? normalizeProvider(resolveRemoteProvider(issueTrackerUrl)) : 'unknown';
+    return {
+        configPath,
+        primaryRemote: remotes.primary,
+        issueTrackerRemote: remotes.issue_tracker,
+        ciRemote: remotes.ci,
+        issueTrackerUrl,
+        issueStorage,
+        provider: storageProvider !== 'unknown' ? storageProvider : urlProvider,
+        secondaryRemotes: remotes.secondary,
+    };
+}
+export function chooseTrackerAccess(authority, probes) {
+    const mcp = probes.find((probe) => probe.kind === 'mcp-app' && probeIsUsable(probe, authority));
+    if (mcp)
+        return { kind: 'mcp-app', provider: authority.provider, label: accessLabel(mcp) };
+    const api = probes.find((probe) => probe.kind === 'http-api' && probeIsUsable(probe, authority));
+    if (api)
+        return { kind: 'http-api', provider: authority.provider, label: accessLabel(api) };
+    const cli = probes.find((probe) => probe.kind === 'cli' && probeIsUsable(probe, authority));
+    if (cli)
+        return { kind: 'cli', provider: authority.provider, label: accessLabel(cli) };
+    return {
+        kind: 'blocker',
+        provider: authority.provider,
+        label: 'stop/report blocker',
+        blocker: [
+            `No usable issue-tracker write path for configured tracker '${authority.issueTrackerRemote}'`,
+            `(provider: ${authority.provider}, url: ${authority.issueTrackerUrl ?? 'unresolved'}).`,
+            'Git SSH remote access only proves repository sync, not issue API access.',
+            'Do not file on mirror or secondary remotes unless the user explicitly requests it.',
+        ].join(' '),
+    };
+}
+export function renderTrackerProtocol(authority) {
+    const secondary = authority.secondaryRemotes.length > 0
+        ? authority.secondaryRemotes
+            .map((remote) => `${remote.name}${remote.purpose ? ` (${remote.purpose})` : ''}`)
+            .join(', ')
+        : 'none configured';
+    const issueStorage = authority.issueStorage ?? 'not configured';
+    const trackerUrl = authority.issueTrackerUrl ?? 'remote URL unavailable';
+    return [
+        '### Tracker Authority Protocol',
+        '',
+        `- Source of truth: [${authority.configPath}](./${authority.configPath})`,
+        `- Canonical tracker: \`${authority.issueTrackerRemote}\` (${authority.provider}; ${trackerUrl})`,
+        `- Primary repo remote: \`${authority.primaryRemote}\`; CI remote: \`${authority.ciRemote}\``,
+        `- Secondary/mirror remotes: ${secondary}`,
+        `- Issue storage mode: ${issueStorage}`,
+        '',
+        'Tracker access order for issue, PR, release, and CI-sensitive tracker operations:',
+        '1. MCP/app tools for the configured tracker.',
+        '2. Tracker HTTP API with configured credentials.',
+        '3. Tracker CLI for the configured tracker, after confirming authentication.',
+        '4. Stop and report a blocker.',
+        '',
+        '- Project config decides tracker authority; installed/authenticated CLIs do not.',
+        '- Git SSH remote access is repository sync, not issue-tracker API access.',
+        '- Do not file on mirror or secondary remotes just because their CLI is authenticated.',
+        '- Treat an unauthenticated tracker CLI as one failed access path, then continue probing MCP/app/API before blocking.',
+    ].join('\n');
+}
+//# sourceMappingURL=capability-protocol.js.map