sdx-cli 0.2.1

package/dist/lib/githubPublish.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGithubPublishOps = createGithubPublishOps;
+const node_buffer_1 = require("node:buffer");
+function isNotFound(error) {
+    return Number(error.status) === 404;
+}
+function parsePrUrl(prUrl) {
+    const match = prUrl.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/i);
+    if (!match) {
+        throw new Error(`Invalid PR URL: ${prUrl}`);
+    }
+    return {
+        owner: match[1],
+        repo: match[2],
+        number: Number(match[3]),
+    };
+}
+async function createOctokit(token) {
+    const { Octokit } = await import('@octokit/rest');
+    return new Octokit({ auth: token });
+}
+function createGithubPublishOps(token) {
+    const octokitPromise = createOctokit(token);
+    return {
+        async ensureBranch(owner, repo, branch) {
+            const octokit = await octokitPromise;
+            const repoData = await octokit.rest.repos.get({ owner, repo });
+            const defaultBranch = repoData.data.default_branch;
+            try {
+                await octokit.rest.git.getRef({ owner, repo, ref: `heads/${branch}` });
+                return { defaultBranch };
+            }
+            catch (error) {
+                if (!isNotFound(error)) {
+                    throw error;
+                }
+            }
+            const baseRef = await octokit.rest.git.getRef({ owner, repo, ref: `heads/${defaultBranch}` });
+            await octokit.rest.git.createRef({
+                owner,
+                repo,
+                ref: `refs/heads/${branch}`,
+                sha: baseRef.data.object.sha,
+            });
+            return { defaultBranch };
+        },
+        async upsertTextFile(owner, repo, branch, filePath, content, commitMessage) {
+            const octokit = await octokitPromise;
+            let existingSha;
+            let existingBody = '';
+            try {
+                const current = await octokit.rest.repos.getContent({
+                    owner,
+                    repo,
+                    path: filePath,
+                    ref: branch,
+                });
+                if (!Array.isArray(current.data) && current.data.type === 'file') {
+                    existingSha = current.data.sha;
+                    const encoded = current.data.content ?? '';
+                    existingBody = node_buffer_1.Buffer.from(encoded, current.data.encoding === 'base64' ? 'base64' : 'utf8').toString('utf8');
+                }
+            }
+            catch (error) {
+                if (!isNotFound(error)) {
+                    throw error;
+                }
+            }
+            if (existingBody === content) {
+                return { changed: false };
+            }
+            await octokit.rest.repos.createOrUpdateFileContents({
+                owner,
+                repo,
+                path: filePath,
+                branch,
+                message: commitMessage,
+                content: node_buffer_1.Buffer.from(content, 'utf8').toString('base64'),
+                sha: existingSha,
+            });
+            return { changed: true };
+        },
+        async readTextFile(owner, repo, filePath, ref) {
+            const octokit = await octokitPromise;
+            try {
+                const current = await octokit.rest.repos.getContent({
+                    owner,
+                    repo,
+                    path: filePath,
+                    ref,
+                });
+                if (Array.isArray(current.data) || current.data.type !== 'file') {
+                    return undefined;
+                }
+                const encoded = current.data.content ?? '';
+                return node_buffer_1.Buffer.from(encoded, current.data.encoding === 'base64' ? 'base64' : 'utf8').toString('utf8');
+            }
+            catch (error) {
+                if (isNotFound(error)) {
+                    return undefined;
+                }
+                throw error;
+            }
+        },
+        async upsertPullRequest(input) {
+            const octokit = await octokitPromise;
+            const { owner, repo, branch, title, body, draft } = input;
+            const repoData = await octokit.rest.repos.get({ owner, repo });
+            const base = repoData.data.default_branch;
+            const open = await octokit.rest.pulls.list({
+                owner,
+                repo,
+                state: 'open',
+                head: `${owner}:${branch}`,
+            });
+            if (open.data.length > 0) {
+                const existing = open.data[0];
+                await octokit.rest.pulls.update({
+                    owner,
+                    repo,
+                    pull_number: existing.number,
+                    title,
+                    body,
+                });
+                return {
+                    number: existing.number,
+                    url: existing.html_url,
+                    created: false,
+                };
+            }
+            const created = await octokit.rest.pulls.create({
+                owner,
+                repo,
+                title,
+                body,
+                head: branch,
+                base,
+                draft,
+            });
+            return {
+                number: created.data.number,
+                url: created.data.html_url,
+                created: true,
+            };
+        },
+        async getPullLifecycle(prUrl) {
+            const octokit = await octokitPromise;
+            const parsed = parsePrUrl(prUrl);
+            const pull = await octokit.rest.pulls.get({
+                owner: parsed.owner,
+                repo: parsed.repo,
+                pull_number: parsed.number,
+            });
+            if (pull.data.merged_at) {
+                return 'merged';
+            }
+            return pull.data.state === 'open' ? 'opened' : 'blocked';
+        },
+    };
+}

package/dist/lib/handoff.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHandoff = buildHandoff;
+exports.renderHandoffMarkdown = renderHandoffMarkdown;
+const constants_1 = require("./constants");
+function buildHandoff(mapId, serviceId, scope, contracts) {
+    const targets = scope.effective
+        .filter((repo) => repo !== serviceId)
+        .map((repo) => {
+        const impactedContracts = contracts
+            .filter((contract) => contract.repo === repo || contract.producers.includes(serviceId))
+            .slice(0, 8);
+        return {
+            repo,
+            summary: `New service '${serviceId}' is available. Validate integration touchpoints for ${repo}.`,
+            requiredChanges: [
+                `Review service-to-service dependency requirements for ${serviceId}.`,
+                `Update integration configuration and environment variables if ${repo} consumes ${serviceId}.`,
+                'Add compatibility checks in CI for the updated API or event contracts.',
+            ],
+            contractImpacts: impactedContracts.length > 0
+                ? impactedContracts.map((contract) => `${contract.type}:${contract.path}`)
+                : ['No direct contracts detected; validate runtime dependencies manually.'],
+            sequencing: 'Integrate in staging first, validate observability signals, then promote to production.',
+        };
+    });
+    return {
+        schemaVersion: constants_1.SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        mapId,
+        serviceId,
+        targets,
+    };
+}
+function renderHandoffMarkdown(handoff) {
+    const lines = [
+        `# Handoff Draft: ${handoff.serviceId}`,
+        '',
+        `- Generated: ${handoff.generatedAt}`,
+        `- Map: ${handoff.mapId}`,
+        '',
+    ];
+    for (const target of handoff.targets) {
+        lines.push(`## ${target.repo}`);
+        lines.push('');
+        lines.push(target.summary);
+        lines.push('');
+        lines.push('Required changes:');
+        for (const item of target.requiredChanges) {
+            lines.push(`- ${item}`);
+        }
+        lines.push('');
+        lines.push('Contract impacts:');
+        for (const impact of target.contractImpacts) {
+            lines.push(`- ${impact}`);
+        }
+        lines.push('');
+        lines.push(`Sequencing: ${target.sequencing}`);
+        lines.push('');
+    }
+    return `${lines.join('\n')}\n`;
+}

package/dist/lib/mapBuilder.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildServiceMapArtifact = buildServiceMapArtifact;
+exports.renderServiceMapMermaid = renderServiceMapMermaid;
+exports.renderServiceMapMarkdown = renderServiceMapMarkdown;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("./constants");
+const fileScan_1 = require("./fileScan");
+const CONTRACT_REGEX = [
+    /openapi.*\.(ya?ml|json)$/i,
+    /swagger\.(ya?ml|json)$/i,
+    /asyncapi.*\.(ya?ml|json)$/i,
+    /\.graphql$/i,
+    /\.gql$/i,
+    /\.proto$/i,
+];
+function classifyContract(filePath) {
+    const lower = filePath.toLowerCase();
+    if (lower.includes('asyncapi') || lower.includes('event')) {
+        return 'event';
+    }
+    return 'api';
+}
+function readPackageDependencies(repoPath) {
+    const packagePath = node_path_1.default.join(repoPath, 'package.json');
+    if (!node_fs_1.default.existsSync(packagePath)) {
+        return [];
+    }
+    try {
+        const data = JSON.parse(node_fs_1.default.readFileSync(packagePath, 'utf8'));
+        const names = new Set([
+            ...Object.keys(data.dependencies ?? {}),
+            ...Object.keys(data.devDependencies ?? {}),
+            ...Object.keys(data.peerDependencies ?? {}),
+        ]);
+        return [...names];
+    }
+    catch {
+        return [];
+    }
+}
+function dedupeNodes(nodes) {
+    const seen = new Set();
+    const out = [];
+    for (const node of nodes) {
+        if (seen.has(node.id)) {
+            continue;
+        }
+        seen.add(node.id);
+        out.push(node);
+    }
+    return out;
+}
+function dedupeEdges(edges) {
+    const seen = new Set();
+    const out = [];
+    for (const edge of edges) {
+        const key = `${edge.from}|${edge.to}|${edge.relation}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        out.push(edge);
+    }
+    return out;
+}
+function buildServiceMapArtifact(mapId, scope, reposByName) {
+    const nodes = [];
+    const edges = [];
+    const effectiveSet = new Set(scope.effective);
+    for (const repoName of scope.effective) {
+        const repo = reposByName.get(repoName);
+        nodes.push({
+            id: `service:${repoName}`,
+            type: 'service',
+            label: repoName,
+            repo: repoName,
+            metadata: {
+                org: repo?.org ?? scope.org,
+            },
+        });
+        nodes.push({
+            id: `repo:${repoName}`,
+            type: 'repo',
+            label: repoName,
+            repo: repoName,
+            metadata: {
+                source: repo?.source ?? 'github',
+                localPath: repo?.localPath,
+            },
+        });
+        edges.push({
+            from: `service:${repoName}`,
+            to: `repo:${repoName}`,
+            relation: 'owns',
+        });
+        if (!repo?.localPath || !node_fs_1.default.existsSync(repo.localPath)) {
+            continue;
+        }
+        const deps = readPackageDependencies(repo.localPath);
+        for (const dep of deps) {
+            if (!effectiveSet.has(dep)) {
+                continue;
+            }
+            edges.push({
+                from: `service:${repoName}`,
+                to: `service:${dep}`,
+                relation: 'depends_on',
+            });
+        }
+        const allFiles = (0, fileScan_1.listFilesRecursive)(repo.localPath);
+        const contractFiles = allFiles.filter((candidate) => CONTRACT_REGEX.some((pattern) => pattern.test(candidate)));
+        for (const contractPath of contractFiles) {
+            const relPath = node_path_1.default.relative(repo.localPath, contractPath);
+            const nodeType = classifyContract(relPath);
+            const contractNodeId = `${nodeType}:${repoName}:${relPath}`;
+            nodes.push({
+                id: contractNodeId,
+                type: nodeType === 'event' ? 'event' : 'api',
+                label: relPath,
+                repo: repoName,
+            });
+            edges.push({
+                from: `service:${repoName}`,
+                to: contractNodeId,
+                relation: nodeType === 'event' ? 'publishes' : 'calls',
+            });
+        }
+    }
+    return {
+        schemaVersion: constants_1.SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        mapId,
+        org: scope.org,
+        repos: [...scope.effective],
+        nodes: dedupeNodes(nodes),
+        edges: dedupeEdges(edges),
+        coverageTags: [...constants_1.PRIMER_DIMENSIONS],
+    };
+}
+function renderServiceMapMermaid(artifact) {
+    const lines = ['flowchart LR'];
+    for (const node of artifact.nodes) {
+        const id = node.id.replace(/[^a-zA-Z0-9_]/g, '_');
+        lines.push(`  ${id}["${node.label}"]`);
+    }
+    for (const edge of artifact.edges) {
+        const from = edge.from.replace(/[^a-zA-Z0-9_]/g, '_');
+        const to = edge.to.replace(/[^a-zA-Z0-9_]/g, '_');
+        lines.push(`  ${from} -->|"${edge.relation}"| ${to}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+function renderServiceMapMarkdown(artifact) {
+    const lines = [
+        `# Service Map: ${artifact.mapId}`,
+        '',
+        `- Generated: ${artifact.generatedAt}`,
+        `- Org: ${artifact.org}`,
+        `- Repos in scope: ${artifact.repos.length}`,
+        `- Nodes: ${artifact.nodes.length}`,
+        `- Edges: ${artifact.edges.length}`,
+        '',
+        '## Repositories',
+        '',
+        ...artifact.repos.map((repo) => `- ${repo}`),
+        '',
+        '## Top Relations',
+        '',
+        ...artifact.edges.slice(0, 30).map((edge) => `- ${edge.from} ${edge.relation} ${edge.to}`),
+        '',
+        '## Coverage Tags',
+        '',
+        ...artifact.coverageTags.map((tag) => `- ${tag}`),
+        '',
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/lib/paths.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectRoot = getProjectRoot;
+exports.getAppDir = getAppDir;
+exports.getConfigPath = getConfigPath;
+exports.getDbPath = getDbPath;
+exports.getMapDir = getMapDir;
+exports.getCatalogDir = getCatalogDir;
+exports.getDocsDir = getDocsDir;
+exports.getCodexDir = getCodexDir;
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("./constants");
+function getProjectRoot(cwd = process.cwd()) {
+    return cwd;
+}
+function getAppDir(cwd = process.cwd()) {
+    return node_path_1.default.join(getProjectRoot(cwd), constants_1.APP_DIR);
+}
+function getConfigPath(cwd = process.cwd()) {
+    return node_path_1.default.join(getAppDir(cwd), constants_1.CONFIG_FILE);
+}
+function getDbPath(cwd = process.cwd()) {
+    return node_path_1.default.join(getAppDir(cwd), constants_1.DB_FILE);
+}
+function getMapDir(mapId, cwd = process.cwd()) {
+    return node_path_1.default.join(getProjectRoot(cwd), 'maps', mapId);
+}
+function getCatalogDir(cwd = process.cwd()) {
+    return node_path_1.default.join(getProjectRoot(cwd), 'catalog');
+}
+function getDocsDir(cwd = process.cwd()) {
+    return node_path_1.default.join(getProjectRoot(cwd), 'docs');
+}
+function getCodexDir(cwd = process.cwd()) {
+    return node_path_1.default.join(getProjectRoot(cwd), 'codex');
+}

package/dist/lib/planReview.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewPlan = reviewPlan;
+exports.renderPlanReviewMarkdown = renderPlanReviewMarkdown;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("./constants");
+function detectMissingNfrs(planText) {
+    const lower = planText.toLowerCase();
+    return constants_1.REQUIRED_NFR_KEYWORDS.filter((keyword) => !lower.includes(keyword));
+}
+function detectImpactedRepos(planText, scope) {
+    const lower = planText.toLowerCase();
+    return scope.effective.filter((repo) => lower.includes(repo.toLowerCase()));
+}
+function detectAssumptions(planText) {
+    const lines = planText.split(/\r?\n/);
+    return lines.filter((line) => /(tbd|todo|assume|unknown)/i.test(line)).slice(0, 20);
+}
+function reviewPlan(mapId, planPath, scope, serviceMap) {
+    const absolute = node_path_1.default.resolve(planPath);
+    const planText = node_fs_1.default.readFileSync(absolute, 'utf8');
+    const missingNfrs = detectMissingNfrs(planText);
+    const impactedRepos = detectImpactedRepos(planText, scope);
+    const unresolvedAssumptions = detectAssumptions(planText);
+    const decisions = [
+        {
+            title: 'Service boundary fit',
+            rationale: impactedRepos.length > 0
+                ? 'Plan references existing repository surfaces and should align integration ownership before implementation.'
+                : 'Plan does not reference existing repos. Validate downstream integration points before implementation.',
+            confidence: impactedRepos.length > 0 ? 0.72 : 0.55,
+            dimensions: ['api_style', 'operational_tradeoffs', 'reliability'],
+        },
+        {
+            title: 'NFR completeness',
+            rationale: missingNfrs.length === 0
+                ? 'Plan includes required NFR categories for latency, availability, durability, SLO intent, and failure handling.'
+                : `Plan is missing required NFR categories: ${missingNfrs.join(', ')}.`,
+            confidence: missingNfrs.length === 0 ? 0.86 : 0.9,
+            dimensions: ['scalability', 'reliability', 'observability', 'consistency_model'],
+        },
+        {
+            title: 'System design coverage breadth',
+            rationale: `Review used ${serviceMap.coverageTags.length} coverage dimensions aligned to the taxonomy baseline.`,
+            confidence: 0.8,
+            dimensions: [...constants_1.PRIMER_DIMENSIONS],
+        },
+    ];
+    return {
+        schemaVersion: constants_1.SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        mapId,
+        planPath: absolute,
+        missingNfrs,
+        accepted: missingNfrs.length === 0,
+        decisions,
+        impactedRepos,
+        unresolvedAssumptions,
+    };
+}
+function renderPlanReviewMarkdown(review) {
+    const lines = [
+        `# Plan Review: ${review.mapId}`,
+        '',
+        `- Generated: ${review.generatedAt}`,
+        `- Plan: ${review.planPath}`,
+        `- Accepted: ${review.accepted ? 'yes' : 'no'}`,
+        `- Missing NFRs: ${review.missingNfrs.length === 0 ? 'none' : review.missingNfrs.join(', ')}`,
+        '',
+        '## Decisions',
+        '',
+        ...review.decisions.map((decision) => `- ${decision.title} (confidence ${decision.confidence.toFixed(2)}): ${decision.rationale} [${decision.dimensions.join(', ')}]`),
+        '',
+        '## Impacted Repositories',
+        '',
+        ...(review.impactedRepos.length > 0 ? review.impactedRepos.map((repo) => `- ${repo}`) : ['- none detected']),
+        '',
+        '## Unresolved Assumptions',
+        '',
+        ...(review.unresolvedAssumptions.length > 0 ? review.unresolvedAssumptions.map((line) => `- ${line}`) : ['- none']),
+        '',
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/lib/project.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureStandardDirs = ensureStandardDirs;
+exports.initProject = initProject;
+exports.loadProject = loadProject;
+exports.recordRun = recordRun;
+exports.ensureMapDir = ensureMapDir;
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("./config");
+const db_1 = require("./db");
+const fs_1 = require("./fs");
+const paths_1 = require("./paths");
+function ensureStandardDirs(cwd = process.cwd()) {
+    (0, fs_1.ensureDir)((0, paths_1.getCatalogDir)(cwd));
+    (0, fs_1.ensureDir)(node_path_1.default.join((0, paths_1.getCatalogDir)(cwd), 'services'));
+    (0, fs_1.ensureDir)(node_path_1.default.join((0, paths_1.getCatalogDir)(cwd), 'contracts'));
+    (0, fs_1.ensureDir)(node_path_1.default.join((0, paths_1.getCatalogDir)(cwd), 'dependencies'));
+    (0, fs_1.ensureDir)((0, paths_1.getDocsDir)(cwd));
+    (0, fs_1.ensureDir)(node_path_1.default.join((0, paths_1.getDocsDir)(cwd), 'architecture'));
+    (0, fs_1.ensureDir)(node_path_1.default.join((0, paths_1.getDocsDir)(cwd), 'adr'));
+    (0, fs_1.ensureDir)(node_path_1.default.join(cwd, 'plans', 'reviews'));
+    (0, fs_1.ensureDir)(node_path_1.default.join(cwd, 'handoffs'));
+    (0, fs_1.ensureDir)(node_path_1.default.join(cwd, 'publish', 'notices'));
+    (0, fs_1.ensureDir)(node_path_1.default.join(cwd, 'publish', 'sync'));
+    (0, fs_1.ensureDir)(node_path_1.default.join((0, paths_1.getCodexDir)(cwd), 'context-packs'));
+    (0, fs_1.ensureDir)(node_path_1.default.join((0, paths_1.getCodexDir)(cwd), 'runs'));
+    (0, fs_1.ensureDir)(node_path_1.default.join(cwd, 'diagrams'));
+    (0, fs_1.ensureDir)(node_path_1.default.join(cwd, 'snapshots'));
+}
+function initProject(cwd = process.cwd()) {
+    if (!(0, config_1.hasConfig)(cwd)) {
+        const config = (0, config_1.createDefaultConfig)(cwd);
+        (0, config_1.saveConfig)(config, cwd);
+    }
+    ensureStandardDirs(cwd);
+    return {
+        cwd,
+        rootDir: (0, paths_1.getProjectRoot)(cwd),
+        db: (0, db_1.openDb)(cwd),
+        config: (0, config_1.loadConfig)(cwd),
+    };
+}
+function loadProject(cwd = process.cwd()) {
+    if (!(0, config_1.hasConfig)(cwd)) {
+        throw new Error('sdx is not initialized. Run `sdx init` first.');
+    }
+    ensureStandardDirs(cwd);
+    return {
+        cwd,
+        rootDir: (0, paths_1.getProjectRoot)(cwd),
+        db: (0, db_1.openDb)(cwd),
+        config: (0, config_1.loadConfig)(cwd),
+    };
+}
+function recordRun(db, runType, status, mapId, metadata) {
+    db.prepare('INSERT INTO run_log (run_type, map_id, status, created_at, metadata_json) VALUES (?, ?, ?, ?, ?)').run(runType, mapId ?? null, status, new Date().toISOString(), metadata ? JSON.stringify(metadata) : null);
+}
+function ensureMapDir(mapId, cwd = process.cwd()) {
+    const mapDir = (0, paths_1.getMapDir)(mapId, cwd);
+    (0, fs_1.ensureDir)(mapDir);
+    return mapDir;
+}

package/dist/lib/promptParser.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePromptIntent = parsePromptIntent;
+exports.renderPromptPreview = renderPromptPreview;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function extractRepoTokens(input, knownRepos) {
+    const uniqueKnown = [...new Set(knownRepos.map((repo) => repo.trim()).filter(Boolean))];
+    if (uniqueKnown.length > 0) {
+        const lowerInput = input.toLowerCase();
+        const matched = [];
+        for (const repo of uniqueKnown) {
+            const escaped = escapeRegExp(repo.toLowerCase());
+            const barePattern = new RegExp(`(^|[^a-zA-Z0-9._-])${escaped}([^a-zA-Z0-9._-]|$)`);
+            const orgPattern = new RegExp(`[a-zA-Z0-9._-]+/${escaped}([^a-zA-Z0-9._-]|$)`);
+            if (barePattern.test(lowerInput) || orgPattern.test(lowerInput)) {
+                matched.push(repo);
+            }
+        }
+        return [...new Set(matched)];
+    }
+    const stopwords = new Set([
+        'include',
+        'exclude',
+        'remove',
+        'status',
+        'build',
+        'map',
+        'from',
+        'the',
+        'and',
+        'in',
+        'to',
+        'for',
+        'of',
+        'with',
+    ]);
+    const matches = input.match(/[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+|[a-zA-Z0-9._-]+/g) ?? [];
+    return [...new Set(matches.filter((token) => !stopwords.has(token.toLowerCase())))];
+}
+function parsePromptIntent(instruction, knownRepos = []) {
+    const lower = instruction.toLowerCase();
+    if (/\bstatus\b/.test(lower)) {
+        return {
+            action: 'status',
+            repos: [],
+            explanation: 'Show map status.',
+        };
+    }
+    if (/\bbuild\b/.test(lower)) {
+        return {
+            action: 'build',
+            repos: [],
+            explanation: 'Build map artifacts for current scope.',
+        };
+    }
+    if (/\b(include|add)\b/.test(lower)) {
+        return {
+            action: 'include',
+            repos: extractRepoTokens(instruction, knownRepos),
+            explanation: 'Add repositories to explicit include overrides.',
+        };
+    }
+    if (/\b(exclude|remove|drop)\b/.test(lower)) {
+        return {
+            action: 'exclude',
+            repos: extractRepoTokens(instruction, knownRepos),
+            explanation: 'Add repositories to explicit exclude overrides.',
+        };
+    }
+    return {
+        action: 'unknown',
+        repos: extractRepoTokens(instruction, knownRepos),
+        explanation: 'No deterministic action matched.',
+    };
+}
+function renderPromptPreview(intent) {
+    const repoText = intent.repos.length > 0 ? intent.repos.join(', ') : 'none';
+    return [
+        '# Prompt Preview',
+        '',
+        `- Action: ${intent.action}`,
+        `- Repositories: ${repoText}`,
+        `- Explanation: ${intent.explanation}`,
+        '',
+    ].join('\n');
+}