mustflow 2.23.0 → 2.25.0

package/dist/cli/lib/local-index/database-read.js

@@ -0,0 +1,88 @@
+import { SEARCH_BACKEND_FTS5, SEARCH_BACKEND_TABLE_SCAN, TEST_DISABLE_FTS5_ENV, } from './constants.js';
+export function toSearchString(value) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    if (value instanceof Uint8Array) {
+        return '';
+    }
+    return String(value);
+}
+export function queryRows(database, sql, params = []) {
+    const [result] = database.exec(sql, params);
+    if (!result) {
+        return [];
+    }
+    return result.values.map((values) => {
+        const row = {};
+        result.columns.forEach((column, index) => {
+            row[column] = values[index] ?? null;
+        });
+        return row;
+    });
+}
+export function searchCapabilities(fts5Available) {
+    return {
+        backend: fts5Available ? SEARCH_BACKEND_FTS5 : SEARCH_BACKEND_TABLE_SCAN,
+        fts5Available,
+    };
+}
+export function detectLocalSearchCapabilities(database) {
+    if (process.env[TEST_DISABLE_FTS5_ENV] === '1') {
+        return searchCapabilities(false);
+    }
+    try {
+        database.run('CREATE VIRTUAL TABLE temp.mustflow_fts5_probe USING fts5(value)');
+        database.run('DROP TABLE temp.mustflow_fts5_probe');
+        return searchCapabilities(true);
+    }
+    catch {
+        return searchCapabilities(false);
+    }
+}
+export function readMetadataValue(database, key) {
+    return toSearchString(queryRows(database, 'SELECT value FROM metadata WHERE key = ?', [key])[0]?.value) || undefined;
+}
+export function hasTable(database, tableName) {
+    return queryRows(database, 'SELECT name FROM sqlite_master WHERE type = "table" AND name = ?', [tableName]).length > 0;
+}
+export function readStoredSearchCapabilities(database) {
+    const fts5Available = readMetadataValue(database, 'search_fts5_available') === 'true';
+    const backend = readMetadataValue(database, 'search_backend');
+    if (backend === SEARCH_BACKEND_FTS5 && hasTable(database, 'search_documents_fts')) {
+        return { backend: SEARCH_BACKEND_FTS5, fts5Available };
+    }
+    return { backend: SEARCH_BACKEND_TABLE_SCAN, fts5Available };
+}
+export function toNullableNumber(value) {
+    if (typeof value !== 'number') {
+        return null;
+    }
+    return Number.isFinite(value) ? value : null;
+}
+export function splitIndexedList(value) {
+    return toSearchString(value)
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .sort((left, right) => left.localeCompare(right));
+}
+export function readCount(database, tableName) {
+    if (!hasTable(database, tableName)) {
+        return 0;
+    }
+    const [row] = queryRows(database, `SELECT COUNT(*) AS count FROM ${tableName}`);
+    const count = row?.count;
+    return typeof count === 'number' && Number.isFinite(count) ? count : 0;
+}
+export function readStoredIndexedPaths(database) {
+    if (!hasTable(database, 'documents')) {
+        return [];
+    }
+    return queryRows(database, 'SELECT path FROM documents ORDER BY path')
+        .map((row) => toSearchString(row.path))
+        .filter(Boolean);
+}
+export function sqlPlaceholders(values) {
+    return values.map(() => '?').join(', ');
+}

package/dist/cli/lib/local-index/effect-graph-read-model.js

@@ -0,0 +1,112 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { getLocalIndexDatabasePath } from './database-path.js';
+import { queryRows, splitIndexedList, toSearchString } from './database-read.js';
+import { getStalePaths } from './freshness.js';
+import { loadSqlJs } from './sql.js';
+function createCommandEffectGraphStatus(databasePath, status, stalePaths = []) {
+    return {
+        source: 'local_index',
+        authority: 'explanation_only',
+        commandAuthority: '.mustflow/config/commands.toml',
+        grantsCommandAuthority: false,
+        status,
+        databasePath,
+        indexFresh: status === 'fresh',
+        stalePaths,
+        writeLocks: [],
+        lockConflicts: [],
+        refreshHint: status === 'fresh' ? null : 'Run `mf index` to refresh command-effect graph explanations.',
+    };
+}
+function mapCommandLockConflict(row, intent) {
+    const targetIsLeft = toSearchString(row.left_intent) === intent;
+    const targetPrefix = targetIsLeft ? 'left' : 'right';
+    const otherPrefix = targetIsLeft ? 'right' : 'left';
+    return {
+        intent: toSearchString(row[`${otherPrefix}_intent`]),
+        lock: toSearchString(row.lock),
+        paths: splitIndexedList(row[`${targetPrefix}_paths`]),
+        modes: splitIndexedList(row[`${targetPrefix}_modes`]),
+        concurrencies: splitIndexedList(row[`${targetPrefix}_concurrencies`]),
+        conflictingPaths: splitIndexedList(row[`${otherPrefix}_paths`]),
+        conflictingModes: splitIndexedList(row[`${otherPrefix}_modes`]),
+        conflictingConcurrencies: splitIndexedList(row[`${otherPrefix}_concurrencies`]),
+    };
+}
+/**
+ * mf:anchor cli.index.command-effect-graph
+ * purpose: Read command-effect lock and conflict explanations from the local SQLite index.
+ * search: mf explain command, command locks, local index, sqlite graph
+ * invariant: Indexed command-effect rows explain current commands.toml only when the index is fresh and never grant command authority.
+ * risk: cache, config
+ */
+function queryLocalCommandEffectGraph(databasePath, database, intent) {
+    const writeLocks = queryRows(database, `
+SELECT lock, paths, modes, sources, concurrencies, effect_count
+FROM command_write_locks
+WHERE intent = ?
+ORDER BY lock
+`, [intent]).map((row) => ({
+        lock: toSearchString(row.lock),
+        paths: splitIndexedList(row.paths),
+        modes: splitIndexedList(row.modes),
+        sources: splitIndexedList(row.sources),
+        concurrencies: splitIndexedList(row.concurrencies),
+        effectCount: typeof row.effect_count === 'number' && Number.isFinite(row.effect_count) ? row.effect_count : 0,
+    }));
+    const lockConflicts = queryRows(database, `
+SELECT
+  left_intent,
+  right_intent,
+  lock,
+  left_paths,
+  right_paths,
+  left_modes,
+  right_modes,
+  left_concurrencies,
+  right_concurrencies
+FROM command_lock_conflicts
+WHERE left_intent = ? OR right_intent = ?
+ORDER BY lock, left_intent, right_intent
+`, [intent, intent]).map((row) => mapCommandLockConflict(row, intent));
+    return {
+        source: 'local_index',
+        authority: 'explanation_only',
+        commandAuthority: '.mustflow/config/commands.toml',
+        grantsCommandAuthority: false,
+        status: 'fresh',
+        databasePath,
+        indexFresh: true,
+        stalePaths: [],
+        writeLocks,
+        lockConflicts,
+        refreshHint: null,
+    };
+}
+export async function readLocalCommandEffectGraph(projectRoot, intent) {
+    const graphs = await readLocalCommandEffectGraphs(projectRoot, [intent]);
+    return graphs.get(intent) ?? createCommandEffectGraphStatus(getLocalIndexDatabasePath(projectRoot), 'unreadable');
+}
+export async function readLocalCommandEffectGraphs(projectRoot, intents) {
+    const databasePath = getLocalIndexDatabasePath(projectRoot);
+    const intentNames = [...new Set(intents)];
+    const statusMap = (status, stalePaths = []) => new Map(intentNames.map((intent) => [intent, createCommandEffectGraphStatus(databasePath, status, stalePaths)]));
+    if (!existsSync(databasePath)) {
+        return statusMap('missing');
+    }
+    const SQL = await loadSqlJs();
+    const database = new SQL.Database(readFileSync(databasePath));
+    try {
+        const stalePaths = getStalePaths(projectRoot, database);
+        if (stalePaths.length > 0) {
+            return statusMap('stale', stalePaths);
+        }
+        return new Map(intentNames.map((intent) => [intent, queryLocalCommandEffectGraph(databasePath, database, intent)]));
+    }
+    catch {
+        return statusMap('unreadable');
+    }
+    finally {
+        database.close();
+    }
+}

package/dist/cli/lib/local-index/freshness.js

@@ -0,0 +1,60 @@
+import { LOCAL_INDEX_SCHEMA_VERSION } from './constants.js';
+import { hasTable, queryRows, readMetadataValue, toSearchString } from './database-read.js';
+import { normalizeIndexedFileSourceScope, readIndexedFileRecord } from './source-index.js';
+import { collectDocuments } from './workflow-documents.js';
+export function readStoredSchemaVersion(database) {
+    return readMetadataValue(database, 'schema_version');
+}
+export function getStalePaths(projectRoot, database) {
+    const schemaVersion = readStoredSchemaVersion(database);
+    if (schemaVersion !== LOCAL_INDEX_SCHEMA_VERSION) {
+        return ['.mustflow/cache/mustflow.sqlite'];
+    }
+    if (hasTable(database, 'indexed_files')) {
+        const stalePaths = new Set();
+        const indexedRows = queryRows(database, 'SELECT path, source_scope, content_hash FROM indexed_files');
+        const indexedPaths = new Set(indexedRows.map((row) => toSearchString(row.path)));
+        for (const row of indexedRows) {
+            const indexedPath = toSearchString(row.path);
+            const sourceScope = normalizeIndexedFileSourceScope(toSearchString(row.source_scope));
+            try {
+                const current = readIndexedFileRecord(projectRoot, indexedPath, sourceScope);
+                if (current.contentHash !== toSearchString(row.content_hash)) {
+                    stalePaths.add(indexedPath);
+                }
+            }
+            catch {
+                stalePaths.add(indexedPath);
+            }
+        }
+        for (const document of collectDocuments(projectRoot)) {
+            if (!indexedPaths.has(document.path)) {
+                stalePaths.add(document.path);
+            }
+        }
+        return Array.from(stalePaths).sort((left, right) => left.localeCompare(right));
+    }
+    const indexedRows = queryRows(database, 'SELECT path, content_hash FROM documents');
+    const indexedHashes = new Map(indexedRows.map((row) => [toSearchString(row.path), toSearchString(row.content_hash)]));
+    const currentDocuments = collectDocuments(projectRoot);
+    const currentHashes = new Map(currentDocuments.map((document) => [document.path, document.contentHash]));
+    const stalePaths = new Set();
+    for (const [indexedPath, indexedHash] of indexedHashes) {
+        if (currentHashes.get(indexedPath) !== indexedHash) {
+            stalePaths.add(indexedPath);
+        }
+    }
+    for (const currentPath of currentHashes.keys()) {
+        if (!indexedHashes.has(currentPath)) {
+            stalePaths.add(currentPath);
+        }
+    }
+    return Array.from(stalePaths).sort((left, right) => left.localeCompare(right));
+}
+export function isLocalIndexStaleError(error) {
+    return error instanceof Error && error.message.startsWith('Local mustflow index is stale:');
+}
+export function isLocalIndexRuntimeUnavailableError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /file is not a database|database disk image is malformed|no such table|no such column|sqlite|sql\.js/iu.test(message);
+}