mustflow 2.22.3 → 2.22.5

package/dist/cli/lib/repo-map.js

@@ -4,7 +4,7 @@ import { existsSync, lstatSync, readdirSync, realpathSync, statSync } from 'node
 import path from 'node:path';
 import { toPosixPath } from './filesystem.js';
 import { writeUtf8FileInsideWithoutSymlinks } from '../../core/safe-filesystem.js';
-import { readTomlFile } from './toml.js';
+import { readMustflowTomlFile } from './toml.js';
 const DEFAULT_DEPTH = 3;
 const REPO_MAP_DOC_ID = 'repo-map';
 const REPO_MAP_LIFECYCLE = 'generated';
@@ -214,7 +214,7 @@ function readMustflowConfig(projectRoot) {
         return {};
     }
     try {
-        const parsed = readTomlFile(configPath);
+        const parsed = readMustflowTomlFile(projectRoot, '.mustflow/config/mustflow.toml');
         return isRecord(parsed) ? parsed : {};
     }
     catch {
@@ -243,7 +243,19 @@ function getRepoMapConfig(projectRoot) {
         },
     };
 }
-export function listGitFilesForRepoMap(projectRoot, options = {}) {
+function classifyGitLsFilesFailure(result) {
+    const errorRecord = result.error;
+    const errorCode = typeof errorRecord?.code === 'string' ? errorRecord.code : undefined;
+    const errorMessage = result.error?.message ?? '';
+    if (errorCode === 'ETIMEDOUT' || /timed?\s*out|ETIMEDOUT/iu.test(errorMessage)) {
+        return 'timeout';
+    }
+    if (errorCode === 'ENOBUFS' || /maxBuffer|ENOBUFS|buffer/iu.test(errorMessage)) {
+        return 'max_buffer';
+    }
+    return 'error';
+}
+export function discoverGitFilesForRepoMap(projectRoot, options = {}) {
     const spawnGit = options.spawnGit ??
         ((command, args, spawnOptions) => spawnSync(command, [...args], spawnOptions));
     const result = spawnGit('git', ['ls-files', '-z'], {
@@ -254,12 +266,21 @@ export function listGitFilesForRepoMap(projectRoot, options = {}) {
         windowsHide: true,
     });
     if (result.status !== 0 || result.error) {
-        return [];
+        return {
+            files: [],
+            status: classifyGitLsFilesFailure(result),
+        };
     }
-    return result.stdout
-        .split('\0')
-        .map((line) => toPosixPath(line))
-        .filter(Boolean);
+    return {
+        files: result.stdout
+            .split('\0')
+            .map((line) => toPosixPath(line))
+            .filter(Boolean),
+        status: 'ok',
+    };
+}
+export function listGitFilesForRepoMap(projectRoot, options = {}) {
+    return discoverGitFilesForRepoMap(projectRoot, options).files;
 }
 function isAnchorCandidatePath(relativePath, priorityPaths) {
     return priorityPaths.has(relativePath) || Boolean(getAnchorDescription(relativePath));
@@ -290,13 +311,17 @@ function listAnchorCandidateFilesRecursive(rootPath, depth, priorityPaths) {
 }
 function getRepositoryFiles(projectRoot, depth, priorityPaths) {
     const files = new Set();
-    for (const relativePath of listGitFilesForRepoMap(projectRoot)) {
+    const gitFiles = discoverGitFilesForRepoMap(projectRoot);
+    for (const relativePath of gitFiles.files) {
         files.add(relativePath);
     }
     for (const relativePath of listAnchorCandidateFilesRecursive(projectRoot, depth, priorityPaths)) {
         files.add(relativePath);
     }
-    return Array.from(files);
+    return {
+        files: Array.from(files),
+        gitLsFilesStatus: gitFiles.status,
+    };
 }
 function shouldIncludePath(relativePath) {
     if (GENERATED_FILES.has(relativePath)) {
@@ -341,7 +366,8 @@ function isUnderExcludedPrefix(relativePath, excludedPrefixes) {
     return excludedPrefixes.some((prefix) => relativePath === prefix.slice(0, -1) || relativePath.startsWith(prefix));
 }
 function discoverAnchors(projectRoot, depth, priorityPaths, nestedRepositories, excludedPrefixes) {
-    return getRepositoryFiles(projectRoot, depth, priorityPaths)
+    const repositoryFiles = getRepositoryFiles(projectRoot, depth, priorityPaths);
+    const anchors = repositoryFiles.files
         .filter(shouldIncludePath)
         .filter((relativePath) => !isUnderNestedRepository(relativePath, nestedRepositories))
         .filter((relativePath) => !isUnderExcludedPrefix(relativePath, excludedPrefixes))
@@ -352,6 +378,10 @@ function discoverAnchors(projectRoot, depth, priorityPaths, nestedRepositories,
         .filter((anchor) => Boolean(anchor))
         .filter((anchor) => priorityPaths.has(anchor.relativePath) || getDirectoryDepth(anchor.relativePath) <= depth)
         .sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+    return {
+        anchors,
+        gitLsFilesStatus: repositoryFiles.gitLsFilesStatus,
+    };
 }
 function renderAnchorList(anchors) {
     return anchors.map((anchor) => `- \`${anchor.relativePath}\`: ${anchor.description}`);
@@ -594,10 +624,11 @@ function countNestedEntrypoints(repository) {
         ...repository.editingPolicies,
     ].filter(Boolean).length;
 }
-function getSourceFingerprint(depth, includeNested, configuredPriorityPaths, anchors, nestedRepositories) {
+function getSourceFingerprint(depth, includeNested, configuredPriorityPaths, gitLsFilesStatus, anchors, nestedRepositories) {
     const payload = {
         depth,
         includeNested,
+        gitLsFilesStatus,
         priorityPaths: [...configuredPriorityPaths].sort(),
         anchors: anchors.map((anchor) => anchor.relativePath).sort(),
         nestedRepositories: nestedRepositories
@@ -621,7 +652,8 @@ function getSourceFingerprint(depth, includeNested, configuredPriorityPaths, anc
     const digest = createHash('sha256').update(JSON.stringify(payload)).digest('hex');
     return `sha256:${digest}`;
 }
-function renderRepoMapFrontmatter(anchorCount, sourceFingerprint) {
+function renderRepoMapFrontmatter(anchorCount, sourceFingerprint, gitLsFilesStatus) {
+    const degraded = gitLsFilesStatus !== 'ok';
     return [
         '---',
         `mustflow_doc: ${REPO_MAP_DOC_ID}`,
@@ -631,11 +663,25 @@ function renderRepoMapFrontmatter(anchorCount, sourceFingerprint) {
         `source_policy: ${REPO_MAP_SOURCE_POLICY}`,
         `privacy_mode: ${REPO_MAP_PRIVACY_MODE}`,
         `anchor_count: ${anchorCount}`,
+        `degraded: ${degraded ? 'true' : 'false'}`,
+        `git_ls_files_status: ${gitLsFilesStatus}`,
         `source_fingerprint: "${sourceFingerprint}"`,
         '---',
         '',
     ];
 }
+function renderSourceQuality(gitLsFilesStatus) {
+    if (gitLsFilesStatus === 'ok') {
+        return [];
+    }
+    return [
+        '## Source Quality',
+        '',
+        `- \`git ls-files\` status: \`${gitLsFilesStatus}\``,
+        '- Anchor discovery used the bounded recursive fallback. Treat this map as incomplete until regenerated after Git file discovery succeeds.',
+        '',
+    ];
+}
 export function generateRepoMap(projectRoot, options = {}) {
     const depth = options.depth ?? DEFAULT_DEPTH;
     const config = getRepoMapConfig(projectRoot);
@@ -647,15 +693,17 @@ export function generateRepoMap(projectRoot, options = {}) {
     };
     const nestedRepositories = discoverNestedRepositories(projectRoot, mapConfig, config.workspace);
     const workspaceRootPrefixes = getWorkspaceRootPrefixes(projectRoot, config.workspace);
-    const anchors = discoverAnchors(projectRoot, depth, priorityPathSet, nestedRepositories, workspaceRootPrefixes);
+    const anchorDiscovery = discoverAnchors(projectRoot, depth, priorityPathSet, nestedRepositories, workspaceRootPrefixes);
+    const anchors = anchorDiscovery.anchors;
+    const gitLsFilesStatus = anchorDiscovery.gitLsFilesStatus;
     const priorityAnchors = configuredPriorityPaths
         .map((relativePath) => anchors.find((anchor) => anchor.relativePath === relativePath))
         .filter((anchor) => Boolean(anchor));
     const otherAnchors = anchors.filter((anchor) => !priorityPathSet.has(anchor.relativePath));
     const anchorCount = anchors.length + nestedRepositories.reduce((total, repository) => total + countNestedEntrypoints(repository), 0);
-    const sourceFingerprint = getSourceFingerprint(depth, mapConfig.includeNested, configuredPriorityPaths, anchors, nestedRepositories);
+    const sourceFingerprint = getSourceFingerprint(depth, mapConfig.includeNested, configuredPriorityPaths, gitLsFilesStatus, anchors, nestedRepositories);
     return [
-        ...renderRepoMapFrontmatter(anchorCount, sourceFingerprint),
+        ...renderRepoMapFrontmatter(anchorCount, sourceFingerprint, gitLsFilesStatus),
         '# REPO_MAP.md',
         '',
         'This file is an agent navigation map for the current mustflow root. It is not a full file listing.',
@@ -670,6 +718,7 @@ export function generateRepoMap(projectRoot, options = {}) {
             : []),
         '- Use `git ls-files` or your editor when you need the complete file list.',
         '',
+        ...renderSourceQuality(gitLsFilesStatus),
         '## Priority Anchors',
         '',
         ...(priorityAnchors.length > 0 ? renderAnchorList(priorityAnchors) : ['No mustflow priority anchors were found.']),

package/dist/cli/lib/templates.js

@@ -2,6 +2,8 @@ import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parse } from 'smol-toml';
+const DEV_TEMPLATE_ROOT_ENV = 'MUSTFLOW_DEV_TEMPLATE_ROOT';
+const ALLOW_DEV_TEMPLATE_ROOT_ENV = 'MUSTFLOW_ALLOW_DEV_TEMPLATE_ROOT';
 function readStringGroup(raw, label) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
         throw new Error(`Template manifest is missing table: ${label}`);
@@ -69,15 +71,124 @@ function shouldIncludeTemplatePath(relativePath, selectedSkills) {
     }
     return selectedSkills.includes(skillName);
 }
+const SKILL_INDEX_SKILL_PATH_PATTERN = /`\.mustflow\/skills\/([^/]+)\/SKILL\.md`/u;
+const SKILL_INDEX_HEADING_PATTERN = /^(#{2,3})\s+(.+?)\s*$/u;
+const SKILL_INDEX_ROUTE_CATEGORY_NAMES = [
+    'Bug and Failure',
+    'General Code Change',
+    'Tests and Regression',
+    'Documentation and Release',
+    'Security and Privacy',
+    'Data and External Systems',
+    'UI and Assets',
+    'Architecture Patterns',
+    'Workflow and Contract Maintenance',
+];
+function skillNameFromSkillIndexLine(line) {
+    return SKILL_INDEX_SKILL_PATH_PATTERN.exec(line)?.[1];
+}
+function parseMarkdownTableCells(line) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine.startsWith('|') || !trimmedLine.endsWith('|')) {
+        return undefined;
+    }
+    return trimmedLine
+        .slice(1, -1)
+        .split('|')
+        .map((cell) => cell.trim());
+}
+function isMarkdownTableDivider(cells) {
+    return cells.every((cell) => /^:?-{3,}:?$/u.test(cell));
+}
+function isMarkdownTableHeading(cells) {
+    const firstCell = cells[0] ?? '';
+    return [
+        'Category',
+        'Classification evidence',
+        'Trigger',
+    ].includes(firstCell);
+}
+function referencedSkillIndexCategories(text) {
+    return SKILL_INDEX_ROUTE_CATEGORY_NAMES.filter((categoryName) => text.includes(categoryName));
+}
+function collectSelectedSkillIndexCategories(lines, selectedSkillSet) {
+    const selectedCategories = new Set();
+    let inSpecificRoutes = false;
+    let currentCategory;
+    for (const line of lines) {
+        const heading = SKILL_INDEX_HEADING_PATTERN.exec(line);
+        if (heading) {
+            const [, level, title] = heading;
+            if (level === '##') {
+                inSpecificRoutes = title === 'Specific Routes';
+                currentCategory = undefined;
+                continue;
+            }
+            if (inSpecificRoutes && level === '###') {
+                currentCategory = title;
+            }
+        }
+        const skillName = skillNameFromSkillIndexLine(line);
+        if (inSpecificRoutes && currentCategory && skillName && selectedSkillSet.has(skillName)) {
+            selectedCategories.add(currentCategory);
+        }
+    }
+    return selectedCategories;
+}
+function shouldKeepSkillIndexTableRow(line, currentSection, selectedCategories) {
+    const cells = parseMarkdownTableCells(line);
+    if (!cells || isMarkdownTableDivider(cells) || isMarkdownTableHeading(cells)) {
+        return true;
+    }
+    if (currentSection === 'Route Category Gate') {
+        const categoryName = cells[0] ?? '';
+        return !SKILL_INDEX_ROUTE_CATEGORY_NAMES.includes(categoryName) ||
+            selectedCategories.has(categoryName);
+    }
+    if (currentSection === 'Classification Prefilter') {
+        const categoryNames = referencedSkillIndexCategories(cells.join(' '));
+        return categoryNames.length === 0 || categoryNames.some((categoryName) => selectedCategories.has(categoryName));
+    }
+    return true;
+}
 function filterSkillIndexContent(content, selectedSkills) {
     const selectedSkillSet = new Set(selectedSkills);
-    return content
-        .split(/\r?\n/u)
-        .filter((line) => {
-        const match = /`\.mustflow\/skills\/([^/]+)\/SKILL\.md`/u.exec(line);
-        return !match || selectedSkillSet.has(match[1] ?? '');
-    })
-        .join('\n');
+    const lines = content.split(/\r?\n/u);
+    const selectedCategories = collectSelectedSkillIndexCategories(lines, selectedSkillSet);
+    const filteredLines = [];
+    let currentSection;
+    let skipCurrentSpecificCategory = false;
+    for (const line of lines) {
+        const heading = SKILL_INDEX_HEADING_PATTERN.exec(line);
+        if (heading) {
+            const [, level, title] = heading;
+            if (level === '##') {
+                currentSection = title;
+                skipCurrentSpecificCategory = false;
+                filteredLines.push(line);
+                continue;
+            }
+            if (currentSection === 'Specific Routes' && level === '###') {
+                skipCurrentSpecificCategory = !selectedCategories.has(title);
+                if (!skipCurrentSpecificCategory) {
+                    filteredLines.push(line);
+                }
+                continue;
+            }
+        }
+        if (skipCurrentSpecificCategory) {
+            continue;
+        }
+        const skillName = skillNameFromSkillIndexLine(line);
+        if (skillName && !selectedSkillSet.has(skillName)) {
+            continue;
+        }
+        if (!shouldKeepSkillIndexTableRow(line, currentSection, selectedCategories)) {
+            continue;
+        }
+        filteredLines.push(line);
+    }
+    return filteredLines.join('\n').replace(/\n{3,}/gu, '\n\n');
 }
 function filterSkillRouteMetadataContent(content, selectedSkills) {
     const selectedSkillSet = new Set(selectedSkills);
@@ -166,7 +277,12 @@ function readManifest(manifestPath) {
     };
 }
 export function getDefaultTemplate() {
-    const templateRoot = path.resolve(process.env.MUSTFLOW_DEV_TEMPLATE_ROOT ?? fileURLToPath(new URL('../../../templates/default', import.meta.url)));
+    const packagedTemplateRoot = fileURLToPath(new URL('../../../templates/default', import.meta.url));
+    const templateRootOverride = process.env[DEV_TEMPLATE_ROOT_ENV];
+    const selectedTemplateRoot = templateRootOverride && process.env[ALLOW_DEV_TEMPLATE_ROOT_ENV] === '1'
+        ? templateRootOverride
+        : packagedTemplateRoot;
+    const templateRoot = path.resolve(selectedTemplateRoot);
     const manifestPath = path.join(templateRoot, 'manifest.toml');
     const manifest = readManifest(manifestPath);
     return {

package/dist/cli/lib/toml.js

@@ -1 +1,6 @@
-export { parseTomlText, readTomlFile, stringifyToml } from '../../core/toml.js';
+import { parseTomlText, readTomlFile, stringifyToml } from '../../core/toml.js';
+import { MUSTFLOW_TOML_MAX_BYTES, readMustflowTextFile } from './mustflow-read.js';
+export { parseTomlText, readTomlFile, stringifyToml };
+export function readMustflowTomlFile(projectRoot, relativePath) {
+    return parseTomlText(readMustflowTextFile(projectRoot, relativePath, { maxBytes: MUSTFLOW_TOML_MAX_BYTES }));
+}

package/dist/cli/lib/validation/constants.js

@@ -198,6 +198,8 @@ export const REPO_MAP_RELATIVE_ROOT = '.';
 export const REPO_MAP_SOURCE_POLICY = 'anchors_only';
 export const REPO_MAP_PRIVACY_MODE = 'minimal';
 export const REPO_MAP_SOURCE_FINGERPRINT_PATTERN = /^sha256:[a-f0-9]{64}$/u;
+export const ALLOWED_REPO_MAP_DEGRADED_VALUES = new Set(['true', 'false']);
+export const ALLOWED_REPO_MAP_GIT_LS_FILES_STATUSES = new Set(['ok', 'timeout', 'max_buffer', 'error']);
 export const SKILL_RESOURCE_MANIFEST = 'resources.toml';
 export const SKILL_RESOURCE_ROOTS = new Set(['references', 'assets', 'scripts']);
 export const ALLOWED_SKILL_RESOURCE_TYPES = new Set(['reference', 'asset', 'script']);