mustflow 2.84.0 → 2.99.0

package/dist/core/repo-version-source.js

@@ -0,0 +1,82 @@
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { isRecord, readMustflowOwnedTomlFile } from './config-loading.js';
+import { detectVersionSources, releaseVersioningIsEnabled, VERSIONING_CONFIG_PATH, } from './version-sources.js';
+export const REPO_VERSION_SOURCE_PACK_ID = 'repo';
+export const REPO_VERSION_SOURCE_SCRIPT_ID = 'version-source';
+export const REPO_VERSION_SOURCE_SCRIPT_REF = `${REPO_VERSION_SOURCE_PACK_ID}/${REPO_VERSION_SOURCE_SCRIPT_ID}`;
+export const REPO_VERSION_SOURCE_PREFERENCES_PATH = '.mustflow/config/preferences.toml';
+function sha256(value) {
+    return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+function readPreferences(projectRoot, issues) {
+    const preferencesPath = path.join(projectRoot, ...REPO_VERSION_SOURCE_PREFERENCES_PATH.split('/'));
+    if (!existsSync(preferencesPath)) {
+        return undefined;
+    }
+    try {
+        const parsed = readMustflowOwnedTomlFile(projectRoot, REPO_VERSION_SOURCE_PREFERENCES_PATH);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        issues.push(`Could not read ${REPO_VERSION_SOURCE_PREFERENCES_PATH}: ${message}`);
+        return undefined;
+    }
+}
+function countSources(sources) {
+    return {
+        sources: sources.length,
+        declared_sources: sources.filter((source) => source.declared === true).length,
+        source_authority_sources: sources.filter((source) => source.authority === 'source').length,
+        derived_authority_sources: sources.filter((source) => source.authority === 'derived').length,
+        unclassified_authority_sources: sources.filter((source) => source.authority === undefined).length,
+    };
+}
+function createInputHash(reportInput) {
+    return sha256(JSON.stringify(reportInput));
+}
+export function inspectRepoVersionSource(projectRoot) {
+    const root = path.resolve(projectRoot);
+    const issues = [];
+    const preferences = readPreferences(root, issues);
+    const versioningEnabled = releaseVersioningIsEnabled(preferences);
+    const sources = detectVersionSources(root);
+    const findings = [];
+    if (versioningEnabled && sources.length === 0) {
+        findings.push({
+            code: 'versioning_enabled_without_sources',
+            severity: 'high',
+            path: REPO_VERSION_SOURCE_PREFERENCES_PATH,
+            message: 'Release versioning preferences are enabled, but no version source was detected.',
+            json_pointer: null,
+            metric: null,
+            actual: 0,
+            expected: 1,
+        });
+    }
+    const counts = countSources(sources);
+    const status = issues.length > 0 ? 'error' : findings.length > 0 ? 'failed' : 'passed';
+    return {
+        schema_version: '1',
+        command: 'script-pack',
+        pack_id: REPO_VERSION_SOURCE_PACK_ID,
+        script_id: REPO_VERSION_SOURCE_SCRIPT_ID,
+        script_ref: REPO_VERSION_SOURCE_SCRIPT_REF,
+        action: 'inspect',
+        status,
+        ok: status === 'passed',
+        mustflow_root: root,
+        input: {
+            preferences_path: REPO_VERSION_SOURCE_PREFERENCES_PATH,
+            declared_sources_path: VERSIONING_CONFIG_PATH,
+        },
+        input_hash: createInputHash({ versioningEnabled, counts, sources, findings, issues }),
+        versioning_enabled: versioningEnabled,
+        counts,
+        sources,
+        findings,
+        issues,
+    };
+}

package/dist/core/route-outline.js

@@ -821,20 +821,72 @@ function extractNestjsLifecycleDecorator(line) {
         : null;
 }
 function extractNestjsHandlerName(line) {
-    const match = /^\s*(?:public\s+|private\s+|protected\s+|async\s+|static\s+|readonly\s+|\*?\s*)*[$A-Z_a-z][$\w]*\s*\(/u.exec(line);
-    if (!match) {
+    const signature = line.trimStart();
+    if (signature.length === 0) {
         return null;
     }
-    const named = /(?<name>[$A-Z_a-z][$\w]*)\s*\(/u.exec(line);
-    const name = named?.groups?.name;
-    if (!name) {
+    let offset = signature.startsWith('*') ? 1 : 0;
+    offset = skipAsciiWhitespace(signature, offset);
+    while (true) {
+        const next = readIdentifier(signature, offset);
+        if (next === null || !isNestjsHandlerModifier(next.value)) {
+            break;
+        }
+        offset = skipAsciiWhitespace(signature, next.end);
+    }
+    if (signature.charAt(offset) === '*') {
+        offset = skipAsciiWhitespace(signature, offset + 1);
+    }
+    const nameToken = readIdentifier(signature, offset);
+    if (nameToken === null) {
         return null;
     }
+    const callStart = skipAsciiWhitespace(signature, nameToken.end);
+    if (signature.charAt(callStart) !== '(') {
+        return null;
+    }
+    const name = nameToken.value;
     if (/\b(?:if|for|while|switch|return|class|interface|function|new|throw|typeof|in|of)\b/u.test(name)) {
         return null;
     }
     return name;
 }
+function skipAsciiWhitespace(text, offset) {
+    let index = offset;
+    while (index < text.length) {
+        const code = text.charCodeAt(index);
+        if (code !== 9 && code !== 10 && code !== 11 && code !== 12 && code !== 13 && code !== 32) {
+            break;
+        }
+        index += 1;
+    }
+    return index;
+}
+function readIdentifier(text, offset) {
+    const first = text.charCodeAt(offset);
+    if (!isIdentifierStart(first)) {
+        return null;
+    }
+    let end = offset + 1;
+    while (end < text.length && isIdentifierPart(text.charCodeAt(end))) {
+        end += 1;
+    }
+    return { value: text.slice(offset, end), end };
+}
+function isIdentifierStart(code) {
+    return code === 36 || code === 95 || (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+}
+function isIdentifierPart(code) {
+    return isIdentifierStart(code) || (code >= 48 && code <= 57);
+}
+function isNestjsHandlerModifier(value) {
+    return (value === 'public' ||
+        value === 'private' ||
+        value === 'protected' ||
+        value === 'async' ||
+        value === 'static' ||
+        value === 'readonly');
+}
 function extractNestjsRouteEntries(relativePath, language, contentSha256, lines, block) {
     const routes = [];
     let controllerLifecycle = [];

package/dist/core/script-pack-suggestions.js

@@ -2,13 +2,15 @@ import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 const CODE_NAVIGATION_SCRIPT_REFS = new Set([
     'code/outline',
+    'code/dependency-graph',
+    'code/import-cycle',
     'code/symbol-read',
     'code/route-outline',
     'code/export-diff',
     'repo/related-files',
 ]);
 const CONFIG_CHAIN_SURFACES = new Set(['config', 'package', 'source', 'test']);
-const CONFIG_FILE_PATTERN = /(?:^|\/)(?:tsconfig(?:\..*)?\.json|eslint\.config\.[cm]?[jt]s|\.eslintrc(?:\.json)?|\.prettierrc(?:\.json)?|prettier\.config\.[cm]?[jt]s|vite\.config\.[cm]?[jt]s|vitest\.config\.[cm]?[jt]s|tailwind\.config\.[cm]?[jt]s|jest\.config\.[cm]?[jt]s|playwright\.config\.[cm]?[jt]s|astro\.config\.mjs|svelte\.config\.js)$/u;
+const CONFIG_FILE_PATTERN = /(?:^|\/)(?:\.gitignore|\.env\.(?:example|sample|template|defaults)|\.dev\.vars\.example|tsconfig(?:\..*)?\.json|eslint\.config\.[cm]?[jt]s|\.eslintrc(?:\.json)?|\.prettierrc(?:\.json)?|prettier\.config\.[cm]?[jt]s|vite\.config\.[cm]?[jt]s|vitest\.config\.[cm]?[jt]s|tailwind\.config\.[cm]?[jt]s|jest\.config\.[cm]?[jt]s|playwright\.config\.[cm]?[jt]s|astro\.config\.mjs|svelte\.config\.js)$/u;
 export function isScriptPackSuggestionPhase(value) {
     return ['before_change', 'during_change', 'after_change', 'review'].includes(value);
 }
@@ -121,7 +123,13 @@ function surfacesForScript(script) {
     addIf('generated', /generated|protected|vendor|cache|boundary/u);
     addIf('config', /config|command/u);
     addIf('package', /package|release/u);
+    addIf('test', /test|suite|fixture|coverage|selection|timing|performance/u);
     addIf('source', /code|source|symbol/u);
+    if (script.ref === 'repo/manifest-lock-drift') {
+        surfaces.add('config');
+        surfaces.add('generated');
+        surfaces.add('template');
+    }
     return uniqueSortedSurfaces(surfaces);
 }
 function confidenceForScore(score) {
@@ -139,6 +147,10 @@ function pathsWithSurface(analyzedPaths, surface) {
 function hasPathWithSurface(analyzedPaths, surface) {
     return analyzedPaths.some((entry) => entry.surfaces.includes(surface));
 }
+function isGitIgnoreAuditPriorityPath(relativePath) {
+    const normalized = relativePath.replace(/\\/gu, '/').replace(/^\.\/+/u, '');
+    return normalized === '.gitignore' || normalized.endsWith('/.gitignore') || normalized === '.git/info/exclude';
+}
 function firstAvailablePath(analyzedPaths, preferredSurfaces) {
     for (const surface of preferredSurfaces) {
         const [candidate] = pathsWithSurface(analyzedPaths, surface);
@@ -166,6 +178,17 @@ function createRunHint(script, analyzedPaths) {
         }
         return 'After code/outline returns a source anchor, run: mf script-pack run code/symbol-read read --anchor <anchor-id> --json';
     }
+    if (script.ref === 'code/dependency-graph') {
+        const sourcePaths = pathsWithSurface(analyzedPaths, 'source');
+        return createConcretePathHint('mf script-pack run code/dependency-graph scan', sourcePaths, script.usage);
+    }
+    if (script.ref === 'code/import-cycle') {
+        const sourcePaths = pathsWithSurface(analyzedPaths, 'source');
+        return createConcretePathHint('mf script-pack run code/import-cycle check', sourcePaths, script.usage);
+    }
+    if (script.ref === 'code/change-impact') {
+        return 'mf script-pack run code/change-impact analyze --base HEAD --json';
+    }
     if (script.ref === 'code/route-outline') {
         const sourcePaths = pathsWithSurface(analyzedPaths, 'source');
         return createConcretePathHint('mf script-pack run code/route-outline scan', sourcePaths, script.usage);
@@ -191,15 +214,64 @@ function createRunHint(script, analyzedPaths) {
             .map((entry) => entry.path);
         return createConcretePathHint('mf script-pack run docs/reference-drift check', docsPaths, script.usage);
     }
+    if (script.ref === 'docs/link-integrity') {
+        const docsPaths = analyzedPaths
+            .filter((entry) => entry.surfaces.some((surface) => surface === 'docs' || surface === 'schema'))
+            .map((entry) => entry.path);
+        return createConcretePathHint('mf script-pack run docs/link-integrity check', docsPaths, script.usage);
+    }
+    if (script.ref === 'test/performance-report') {
+        return 'mf script-pack run test/performance-report summarize --json';
+    }
+    if (script.ref === 'test/regression-selector') {
+        const testSelectionPaths = analyzedPaths
+            .filter((entry) => entry.surfaces.some((surface) => surface === 'source' || surface === 'test'))
+            .map((entry) => entry.path);
+        const pathPart = testSelectionPaths.length > 0 ? ` ${testSelectionPaths.map(quoteCliArg).join(' ')}` : '';
+        return `mf script-pack run test/regression-selector select${pathPart} --base HEAD --json`;
+    }
     if (script.ref === 'repo/generated-boundary') {
         return createConcretePathHint('mf script-pack run repo/generated-boundary check', analyzedPaths.map((entry) => entry.path), script.usage);
     }
+    if (script.ref === 'repo/merge-conflict-scan') {
+        return createConcretePathHint('mf script-pack run repo/merge-conflict-scan check', analyzedPaths.map((entry) => entry.path), 'mf script-pack run repo/merge-conflict-scan check --json');
+    }
+    if (script.ref === 'repo/git-ignore-audit') {
+        return createConcretePathHint('mf script-pack run repo/git-ignore-audit audit', analyzedPaths.map((entry) => entry.path), 'mf script-pack run repo/git-ignore-audit audit --json');
+    }
+    if (script.ref === 'repo/manifest-lock-drift') {
+        const manifestPaths = analyzedPaths
+            .filter((entry) => entry.surfaces.some((surface) => surface === 'config' || surface === 'template' || surface === 'generated'))
+            .map((entry) => entry.path);
+        return createConcretePathHint('mf script-pack run repo/manifest-lock-drift check', manifestPaths, 'mf script-pack run repo/manifest-lock-drift check --json');
+    }
+    if (script.ref === 'repo/skill-route-audit') {
+        return 'mf script-pack run repo/skill-route-audit audit --json';
+    }
+    if (script.ref === 'repo/version-source') {
+        return 'mf script-pack run repo/version-source inspect --json';
+    }
+    if (script.ref === 'repo/approval-gate') {
+        return 'mf script-pack run repo/approval-gate check --action <action_type> --json';
+    }
     if (script.ref === 'repo/config-chain') {
         const configPaths = analyzedPaths
             .filter((entry) => entry.surfaces.some((surface) => CONFIG_CHAIN_SURFACES.has(surface)))
             .map((entry) => entry.path);
         return createConcretePathHint('mf script-pack run repo/config-chain inspect', configPaths, script.usage);
     }
+    if (script.ref === 'repo/env-contract') {
+        const envPaths = analyzedPaths
+            .filter((entry) => entry.surfaces.some((surface) => surface === 'config' || surface === 'source' || surface === 'docs' || surface === 'package'))
+            .map((entry) => entry.path);
+        return createConcretePathHint('mf script-pack run repo/env-contract scan', envPaths, script.usage);
+    }
+    if (script.ref === 'repo/secret-risk-scan') {
+        const secretRiskPaths = analyzedPaths
+            .filter((entry) => entry.surfaces.some((surface) => surface === 'config' || surface === 'source' || surface === 'docs' || surface === 'package' || surface === 'test'))
+            .map((entry) => entry.path);
+        return createConcretePathHint('mf script-pack run repo/secret-risk-scan scan', secretRiskPaths, script.usage);
+    }
     if (script.ref === 'repo/related-files') {
         const relatedPaths = analyzedPaths
             .filter((entry) => entry.surfaces.some((surface) => surface === 'source' || surface === 'test'))
@@ -260,6 +332,30 @@ export function createScriptPackSuggestionReport(mustflowRoot, options) {
             score += 2;
             reasons.push('Prioritizes generated-boundary checks for generated paths.');
         }
+        if (script.ref === 'repo/merge-conflict-scan' && requestedSurfaces.size > 0) {
+            score += 1;
+            reasons.push('Prioritizes merge-conflict marker scans for changed repository paths.');
+        }
+        if (script.ref === 'repo/git-ignore-audit' &&
+            analyzedPaths.some((entry) => isGitIgnoreAuditPriorityPath(entry.path))) {
+            score += 1;
+            reasons.push('Prioritizes Git ignore evidence for explicit ignore-control paths.');
+        }
+        if (script.ref === 'repo/skill-route-audit' &&
+            (requestedSurfaces.has('skill') || requestedSurfaces.has('template') || requestedSurfaces.has('config'))) {
+            score += 3;
+            reasons.push('Prioritizes skill-route audits for skill, template, and workflow metadata surfaces.');
+        }
+        if (script.ref === 'repo/version-source' &&
+            (requestedSurfaces.has('package') || requestedSurfaces.has('template') || requestedSurfaces.has('config'))) {
+            score += 2;
+            reasons.push('Prioritizes version-source inspection for package, template, and versioning metadata surfaces.');
+        }
+        if (script.ref === 'repo/approval-gate' &&
+            (requestedSurfaces.has('config') || requestedSurfaces.has('package') || requestedSurfaces.has('template'))) {
+            score += 2;
+            reasons.push('Prioritizes approval-gate checks for approval-sensitive workflow and release surfaces.');
+        }
         if (score === 0) {
             return null;
         }