@nexusclawhq/cli 0.2.1

package/dist/nexus-cli/src/services/source-tracker.js

@@ -0,0 +1,709 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSourceSelectionPath = normalizeSourceSelectionPath;
+exports.getTrackingFilePath = getTrackingFilePath;
+exports.resolveTrackedFilePath = resolveTrackedFilePath;
+exports.deriveComponentKey = deriveComponentKey;
+exports.loadTrackingData = loadTrackingData;
+exports.saveTrackingData = saveTrackingData;
+exports.collectLocalSourceFiles = collectLocalSourceFiles;
+exports.collectLocalSourceEntries = collectLocalSourceEntries;
+exports.readSourceFiles = readSourceFiles;
+exports.calculateSourceStatus = calculateSourceStatus;
+exports.writeTrackedSourceFile = writeTrackedSourceFile;
+exports.deleteTrackedSourceFile = deleteTrackedSourceFile;
+exports.syncTrackingWithStatus = syncTrackingWithStatus;
+exports.filterByMetadataSelector = filterByMetadataSelector;
+exports.filterByDirectory = filterByDirectory;
+exports.refreshTrackingWithRemoteStatus = refreshTrackingWithRemoteStatus;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const workspace_contract_1 = require("./workspace-contract");
+const source_tracking_bridge_1 = require("./revision-ledger/source-tracking-bridge");
+const utils_1 = require("./revision-ledger/utils");
+const TRACKING_FILE = '.nexus-source-tracking.json';
+const TRACKING_SCHEMA_VERSION = 2;
+const SOURCE_SUFFIXES = [
+    '.object.json',
+    '.object.yaml',
+    '.object.yml',
+    'object.json',
+    'object.yaml',
+    'object.yml',
+    '.field.json',
+    '.field.yaml',
+    '.field.yml',
+    '.relationship.json',
+    '.relationship.yaml',
+    '.relationship.yml',
+    '.layout.json',
+    '.layout.yaml',
+    '.layout.yml',
+    '.view.json',
+    '.view.yaml',
+    '.view.yml',
+    '.menu.json',
+    '.menu.yaml',
+    '.menu.yml',
+    '.dashboard.json',
+    '.dashboard.yaml',
+    '.dashboard.yml',
+    '.report.json',
+    '.report.yaml',
+    '.report.yml',
+    '.action.json',
+    '.action.yaml',
+    '.action.yml',
+    '.flow.json',
+    '.flow.yaml',
+    '.flow.yml',
+    '.approval.json',
+    '.approval.yaml',
+    '.approval.yml',
+    '.prompt.json',
+    '.prompt.yaml',
+    '.prompt.yml',
+    '.agent.json',
+    '.agent.yaml',
+    '.agent.yml',
+    '.role.json',
+    '.role.yaml',
+    '.role.yml',
+    'role.json',
+    'role.yaml',
+    'role.yml',
+    '.permissionset.json',
+    '.permissionset.yaml',
+    '.permissionset.yml',
+    'permissionset.json',
+    'permissionset.yaml',
+    'permissionset.yml',
+    '.permission.json',
+    '.permission.yaml',
+    '.permission.yml',
+    '.app-meta.xml',
+    '.tab-meta.xml',
+    '.object-meta.xml',
+    '.field-meta.xml',
+    '.recordType-meta.xml',
+    '.validationRule-meta.xml',
+    '.listView-meta.xml',
+    '.compactLayout-meta.xml',
+    '.layout-meta.xml',
+    '.page-meta.xml',
+    '.flow-meta.xml',
+    '.permissionset-meta.xml',
+    '.profile-meta.xml',
+    '.permissionsetgroup-meta.xml',
+    '.role-meta.xml',
+    '.group-meta.xml',
+    '.queue-meta.xml',
+    '.labels-meta.xml',
+    '.md-meta.xml',
+    '.setting-meta.xml',
+    '.resource',
+    '.resource-meta.xml',
+    '.namedCredential-meta.xml',
+    '.remoteSite-meta.xml',
+    '.notification-meta.xml',
+    '.isolated-meta.xml',
+];
+function resolveWorkspaceRoot(baseDir = '.') {
+    const root = path.resolve(baseDir);
+    return path.basename(root) === 'objects'
+        ? path.dirname(root)
+        : (0, workspace_contract_1.findWorkspaceRoot)(root);
+}
+function normalizeSourceSelectionPath(candidate) {
+    const normalized = candidate
+        .replace(/\\/g, '/')
+        .replace(/^\.?\//, '')
+        .replace(/\/$/, '');
+    if (normalized === workspace_contract_1.NEXUS_APP_SOURCE_ROOT) {
+        return '';
+    }
+    return normalized.replace(new RegExp(`^${workspace_contract_1.NEXUS_APP_SOURCE_ROOT.replace(/\//g, '\\/')}/`), '');
+}
+function getTrackingFilePath(baseDir = '.') {
+    return path.join(resolveWorkspaceRoot(baseDir), TRACKING_FILE);
+}
+function isSourceFile(filePath) {
+    return SOURCE_SUFFIXES.some((suffix) => filePath.endsWith(suffix));
+}
+function isTrackedMetadataPath(filePath) {
+    const normalized = normalizeSourceSelectionPath(filePath);
+    return isSourceFile(normalized)
+        && /^(applications|tabs|objects|apps|layouts|pages|views|menus|dashboards|reports|actions|flows|approvals|prompts|agents|permissionsets|profiles|permissionSetGroups|roles|groups|queues|labels|customMetadata|customSettings|staticresources|namedCredentials|remoteSiteSettings|notificationTemplates)\//.test(normalized);
+}
+function isTrackedCodePath(filePath) {
+    const normalized = normalizeSourceSelectionPath(filePath);
+    return /^src\/functions\/.+\.function\.(ts|js)$/.test(normalized)
+        || /^src\/triggers\/[^/]+\/.+\.trigger\.(json|ya?ml)$/.test(normalized)
+        || /^classes\/[^/]+\.npex(-meta\.xml)?$/.test(normalized)
+        || /^triggers\/[^/]+\.trigger(-meta\.xml)?$/.test(normalized)
+        || /^nwc\/[^/]+\/[^/]+\.(html|js|css|js-meta\.xml)$/.test(normalized)
+        || /^isolated\/[^/]+\/[^/]+\.(js|isolated-meta\.xml)$/.test(normalized);
+}
+function inferTrackFromPath(filePath) {
+    return isTrackedCodePath(filePath) ? 'code-extension' : 'metadata-runtime';
+}
+function stableValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => stableValue(item));
+    }
+    if (value && typeof value === 'object') {
+        return Object.keys(value)
+            .sort((left, right) => left.localeCompare(right))
+            .reduce((accumulator, key) => {
+            accumulator[key] = stableValue(value[key]);
+            return accumulator;
+        }, {});
+    }
+    return value;
+}
+function stableStringify(value) {
+    return JSON.stringify(stableValue(value));
+}
+function parseStructuredContent(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        try {
+            return yaml.load(content);
+        }
+        catch {
+            return content;
+        }
+    }
+}
+function hashContent(content) {
+    const canonical = parseStructuredContent(content);
+    const payload = typeof canonical === 'string'
+        ? canonical
+        : stableStringify(canonical);
+    return crypto.createHash('sha256').update(payload).digest('hex');
+}
+function toTrackedPath(workspaceRoot, absolutePath) {
+    return path.relative(workspaceRoot, absolutePath).replace(/\\/g, '/');
+}
+function resolveTrackedFilePath(baseDir, trackedPath) {
+    const workspaceRoot = resolveWorkspaceRoot(baseDir);
+    if (trackedPath.replace(/\\/g, '/').startsWith('src/')) {
+        return path.join(workspaceRoot, trackedPath);
+    }
+    if (trackedPath.replace(/\\/g, '/').startsWith(`${workspace_contract_1.NEXUS_APP_SOURCE_ROOT}/`)) {
+        return path.join(workspaceRoot, trackedPath);
+    }
+    return (0, workspace_contract_1.resolvePhysicalSourcePath)(workspaceRoot, normalizeSourceSelectionPath(trackedPath), (0, workspace_contract_1.resolvePreferredMetadataRoot)(workspaceRoot));
+}
+function deriveComponentKey(trackedPath) {
+    const normalized = normalizeSourceSelectionPath(trackedPath);
+    const functionMatch = normalized.match(/^src\/functions\/(.+)\.function\.(ts|js)$/);
+    if (functionMatch) {
+        return `function:${functionMatch[1]}`;
+    }
+    const triggerMatch = normalized.match(/^src\/triggers\/([^/]+)\/(.+)\.trigger\.(json|ya?ml)$/);
+    if (triggerMatch) {
+        return `trigger:${triggerMatch[1]}.${triggerMatch[2]}`;
+    }
+    const applicationMetaMatch = normalized.match(/^applications\/(.+)\.app-meta\.xml$/);
+    if (applicationMetaMatch) {
+        return `application:${applicationMetaMatch[1]}`;
+    }
+    const tabMetaMatch = normalized.match(/^tabs\/(.+)\.tab-meta\.xml$/);
+    if (tabMetaMatch) {
+        return `tab:${tabMetaMatch[1]}`;
+    }
+    const objectMatch = normalized.match(/^objects\/([^/]+)\/object\.(json|ya?ml)$/);
+    if (objectMatch) {
+        return `object:${objectMatch[1]}`;
+    }
+    const objectMetaMatch = normalized.match(/^objects\/([^/]+)\/\1\.object-meta\.xml$/);
+    if (objectMetaMatch) {
+        return `object:${objectMetaMatch[1]}`;
+    }
+    const fieldMatch = normalized.match(/^objects\/([^/]+)\/fields\/(.+)\.field\.(json|ya?ml)$/);
+    if (fieldMatch) {
+        return `field:${fieldMatch[1]}.${fieldMatch[2]}`;
+    }
+    const fieldMetaMatch = normalized.match(/^objects\/([^/]+)\/fields\/(.+)\.field-meta\.xml$/);
+    if (fieldMetaMatch) {
+        return `field:${fieldMetaMatch[1]}.${fieldMetaMatch[2]}`;
+    }
+    const objectChildMetaMatch = normalized.match(/^objects\/([^/]+)\/(recordTypes|validationRules|listViews|compactLayouts)\/(.+)\.([^.]+)-meta\.xml$/);
+    if (objectChildMetaMatch) {
+        return `${objectChildMetaMatch[2]}:${objectChildMetaMatch[1]}.${objectChildMetaMatch[3]}`;
+    }
+    const relationshipMatch = normalized.match(/^objects\/([^/]+)\/relationships\/(.+)\.relationship\.(json|ya?ml)$/);
+    if (relationshipMatch) {
+        return `relationship:${relationshipMatch[1]}.${relationshipMatch[2]}`;
+    }
+    const layoutMatch = normalized.match(/^layouts\/([^/]+)\/(.+)\.layout\.(json|ya?ml)$/);
+    if (layoutMatch) {
+        return `layout:${layoutMatch[1]}.${layoutMatch[2]}`;
+    }
+    const layoutMetaMatch = normalized.match(/^layouts\/(.+)\.layout-meta\.xml$/);
+    if (layoutMetaMatch) {
+        return `layout:${layoutMetaMatch[1]}`;
+    }
+    const pageMetaMatch = normalized.match(/^pages\/(.+)\.page-meta\.xml$/);
+    if (pageMetaMatch) {
+        return `page:${pageMetaMatch[1]}`;
+    }
+    const viewMatch = normalized.match(/^views\/([^/]+)\/(.+)\.view\.(json|ya?ml)$/);
+    if (viewMatch) {
+        return `view:${viewMatch[1]}.${viewMatch[2]}`;
+    }
+    const appMatch = normalized.match(/^apps\/(.+)\.app\.(json|ya?ml)$/);
+    if (appMatch) {
+        return `app:${appMatch[1]}`;
+    }
+    const menuMatch = normalized.match(/^menus\/([^/]+)\/(.+)\.menu\.(json|ya?ml)$/);
+    if (menuMatch) {
+        return `menu:${menuMatch[1]}.${menuMatch[2]}`;
+    }
+    const dashboardMatch = normalized.match(/^dashboards\/(.+)\.dashboard\.(json|ya?ml)$/);
+    if (dashboardMatch) {
+        return `dashboard:${dashboardMatch[1]}`;
+    }
+    const reportMatch = normalized.match(/^reports\/([^/]+)\/(.+)\.report\.(json|ya?ml)$/);
+    if (reportMatch) {
+        return `report:${reportMatch[1]}.${reportMatch[2]}`;
+    }
+    const actionMatch = normalized.match(/^actions\/(.+)\.action\.(json|ya?ml)$/);
+    if (actionMatch) {
+        return `action:${actionMatch[1]}`;
+    }
+    const flowMatch = normalized.match(/^flows\/(.+)\.flow\.(json|ya?ml)$/);
+    if (flowMatch) {
+        return `flow:${flowMatch[1]}`;
+    }
+    const flowMetaMatch = normalized.match(/^flows\/(.+)\.flow-meta\.xml$/);
+    if (flowMetaMatch) {
+        return `flow:${flowMetaMatch[1]}`;
+    }
+    const approvalMatch = normalized.match(/^approvals\/(.+)\.approval\.(json|ya?ml)$/);
+    if (approvalMatch) {
+        return `approval:${approvalMatch[1]}`;
+    }
+    const promptMatch = normalized.match(/^prompts\/([^/]+)\/(.+)\.prompt\.(json|ya?ml)$/);
+    if (promptMatch) {
+        return `prompt:${promptMatch[1]}.${promptMatch[2]}`;
+    }
+    const agentMatch = normalized.match(/^agents\/(.+)\.agent\.(json|ya?ml)$/);
+    if (agentMatch) {
+        return `agent:${agentMatch[1]}`;
+    }
+    const permissionSetMatch = normalized.match(/^permissionsets\/([^/]+)\/permissionset\.(json|ya?ml)$/);
+    if (permissionSetMatch) {
+        return `permissionset:${permissionSetMatch[1]}`;
+    }
+    const permissionSetMetaMatch = normalized.match(/^permissionsets\/(.+)\.permissionset-meta\.xml$/);
+    if (permissionSetMetaMatch) {
+        return `permissionset:${permissionSetMetaMatch[1]}`;
+    }
+    const profileMetaMatch = normalized.match(/^profiles\/(.+)\.profile-meta\.xml$/);
+    if (profileMetaMatch) {
+        return `profile:${profileMetaMatch[1]}`;
+    }
+    const roleMatch = normalized.match(/^roles\/([^/]+)\/role\.(json|ya?ml)$/);
+    if (roleMatch) {
+        return `role:${roleMatch[1]}`;
+    }
+    const roleMetaMatch = normalized.match(/^roles\/(.+)\.role-meta\.xml$/);
+    if (roleMetaMatch) {
+        return `role:${roleMetaMatch[1]}`;
+    }
+    const permissionMatch = normalized.match(/^permissionsets\/([^/]+)\/permissions\/(.+)\.permission\.(json|ya?ml)$/);
+    if (permissionMatch) {
+        return `permission:${permissionMatch[1]}.${permissionMatch[2]}`;
+    }
+    const rolePermissionMatch = normalized.match(/^roles\/([^/]+)\/permissions\/(.+)\.permission\.(json|ya?ml)$/);
+    if (rolePermissionMatch) {
+        return `permission:role.${rolePermissionMatch[1]}.${rolePermissionMatch[2]}`;
+    }
+    const nwcMatch = normalized.match(/^nwc\/([^/]+)\//);
+    if (nwcMatch) {
+        return `nwc:${nwcMatch[1]}`;
+    }
+    const npexMatch = normalized.match(/^classes\/(.+)\.npex(?:-meta\.xml)?$/);
+    if (npexMatch) {
+        return `npex:${npexMatch[1]}`;
+    }
+    const triggerMetaMatch = normalized.match(/^triggers\/(.+)\.trigger(?:-meta\.xml)?$/);
+    if (triggerMetaMatch) {
+        return `trigger:${triggerMetaMatch[1]}`;
+    }
+    const isolatedMatch = normalized.match(/^isolated\/([^/]+)\//);
+    if (isolatedMatch) {
+        return `isolated:${isolatedMatch[1]}`;
+    }
+    return `file:${normalized}`;
+}
+function createEmptyTracking() {
+    return {
+        schemaVersion: TRACKING_SCHEMA_VERSION,
+        workspaceRoot: '.',
+        files: {},
+    };
+}
+function migrateTracking(raw) {
+    if (raw
+        && typeof raw === 'object'
+        && raw.schemaVersion === TRACKING_SCHEMA_VERSION
+        && typeof raw.files === 'object') {
+        const current = raw;
+        for (const [filePath, entry] of Object.entries(current.files)) {
+            entry.track ??= inferTrackFromPath(filePath);
+        }
+        return current;
+    }
+    const legacy = raw;
+    const migrated = createEmptyTracking();
+    for (const [filePath, entry] of Object.entries(legacy?.files ?? {})) {
+        migrated.files[filePath] = {
+            componentKey: deriveComponentKey(filePath),
+            track: inferTrackFromPath(filePath),
+            localHash: entry.localHash,
+            remoteHash: entry.remoteHash,
+            lastSyncedHash: entry.lastPushedHash,
+            baselineHash: null,
+        };
+    }
+    return migrated;
+}
+function loadTrackingData(baseDir = '.') {
+    const environment = (0, utils_1.resolveRevisionEnvironment)();
+    const projected = (0, source_tracking_bridge_1.loadSourceTrackingProjection)(baseDir, environment);
+    if (projected) {
+        return projected;
+    }
+    const trackingPath = getTrackingFilePath(baseDir);
+    if (!fs.existsSync(trackingPath)) {
+        return createEmptyTracking();
+    }
+    try {
+        return migrateTracking(JSON.parse(fs.readFileSync(trackingPath, 'utf-8')));
+    }
+    catch {
+        return createEmptyTracking();
+    }
+}
+function saveTrackingData(baseDir, data) {
+    fs.writeFileSync(getTrackingFilePath(baseDir), `${JSON.stringify(data, null, 2)}\n`, 'utf-8');
+    (0, source_tracking_bridge_1.saveSourceTrackingProjection)(baseDir, (0, utils_1.resolveRevisionEnvironment)(), data);
+}
+function collectLocalSourceFiles(baseDir = '.') {
+    const workspaceRoot = resolveWorkspaceRoot(baseDir);
+    const metadataRoots = (0, workspace_contract_1.getMetadataSourceRoots)(workspaceRoot);
+    const codeRoots = (0, workspace_contract_1.getCodeSourceRoots)(workspaceRoot);
+    const files = new Set();
+    const skippedDirectoryNames = new Set(['node_modules', '.git', 'dist', 'coverage']);
+    const visit = (absolutePath, rootKind) => {
+        if (!fs.existsSync(absolutePath)) {
+            return;
+        }
+        const stats = fs.statSync(absolutePath);
+        if (stats.isDirectory()) {
+            if (skippedDirectoryNames.has(path.basename(absolutePath))) {
+                return;
+            }
+            for (const entry of fs.readdirSync(absolutePath)) {
+                visit(path.join(absolutePath, entry), rootKind);
+            }
+            return;
+        }
+        const metadataTrackedPath = (0, workspace_contract_1.normalizeTrackedMetadataPath)(workspaceRoot, absolutePath);
+        const trackedPath = rootKind === 'metadata-runtime'
+            ? (metadataTrackedPath ?? toTrackedPath(workspaceRoot, absolutePath))
+            : (metadataTrackedPath && isTrackedCodePath(metadataTrackedPath)
+                ? metadataTrackedPath
+                : toTrackedPath(workspaceRoot, absolutePath));
+        if ((rootKind === 'metadata-runtime' && isTrackedMetadataPath(trackedPath)) || isTrackedCodePath(trackedPath)) {
+            files.add(trackedPath);
+        }
+    };
+    for (const sourceRoot of metadataRoots) {
+        const absoluteRoot = sourceRoot.path === '.'
+            ? workspaceRoot
+            : path.join(workspaceRoot, sourceRoot.path);
+        visit(absoluteRoot, 'metadata-runtime');
+    }
+    for (const sourceRoot of codeRoots) {
+        const absoluteRoot = sourceRoot.path === '.'
+            ? workspaceRoot
+            : path.join(workspaceRoot, sourceRoot.path);
+        visit(absoluteRoot, 'code-extension');
+    }
+    return Array.from(files).sort((left, right) => left.localeCompare(right));
+}
+function collectLocalSourceEntries(baseDir = '.') {
+    return collectLocalSourceFiles(baseDir).map((trackedPath) => {
+        const absolutePath = resolveTrackedFilePath(baseDir, trackedPath);
+        const content = fs.readFileSync(absolutePath, 'utf-8');
+        const track = inferTrackFromPath(trackedPath);
+        return {
+            path: trackedPath,
+            absolutePath,
+            content,
+            hash: hashContent(content),
+            componentKey: deriveComponentKey(trackedPath),
+            track,
+        };
+    });
+}
+function readSourceFiles(baseDir = '.') {
+    return collectLocalSourceEntries(baseDir).map((entry) => ({
+        path: entry.path,
+        content: entry.content,
+    }));
+}
+function determineSyncStatus(input) {
+    const { localHash, remoteHash, lastSyncedHash } = input;
+    if (!lastSyncedHash) {
+        if (localHash && remoteHash) {
+            return localHash === remoteHash ? 'synced' : 'conflict';
+        }
+        if (localHash) {
+            return 'local-new';
+        }
+        if (remoteHash) {
+            return 'remote-new';
+        }
+        return 'synced';
+    }
+    const localChanged = localHash !== lastSyncedHash;
+    const remoteChanged = remoteHash !== lastSyncedHash;
+    if (!localChanged && !remoteChanged) {
+        return 'synced';
+    }
+    if (localChanged && remoteChanged) {
+        return localHash === remoteHash ? 'synced' : 'conflict';
+    }
+    if (localChanged) {
+        return localHash ? 'local-changed' : 'local-delete';
+    }
+    return remoteHash ? 'remote-changed' : 'remote-delete';
+}
+function calculateSourceStatus(input) {
+    const baseDir = input.baseDir ?? '.';
+    const localEntries = collectLocalSourceEntries(baseDir);
+    const tracking = loadTrackingData(baseDir);
+    const localByPath = new Map(localEntries.map((entry) => [entry.path, entry]));
+    const remoteByPath = new Map((input.remoteFiles ?? []).map((file) => [file.path, file]));
+    const baselineByPath = new Map((input.baselineFiles ?? []).map((file) => [file.path, file]));
+    const allPaths = new Set([
+        ...localByPath.keys(),
+        ...remoteByPath.keys(),
+        ...baselineByPath.keys(),
+        ...Object.keys(tracking.files),
+    ]);
+    const statuses = [];
+    for (const trackedPath of Array.from(allPaths).sort((left, right) => left.localeCompare(right))) {
+        const localEntry = localByPath.get(trackedPath);
+        const remoteEntry = remoteByPath.get(trackedPath);
+        const trackedEntry = tracking.files[trackedPath];
+        const baselineEntry = baselineByPath.get(trackedPath);
+        const localHash = localEntry?.hash ?? '';
+        const remoteHash = remoteEntry?.hash ?? trackedEntry?.remoteHash ?? '';
+        const lastSyncedHash = trackedEntry?.lastSyncedHash ?? '';
+        const baselineHash = baselineEntry?.hash ?? trackedEntry?.baselineHash ?? null;
+        if (!localHash && !remoteHash && !baselineHash) {
+            continue;
+        }
+        statuses.push({
+            path: trackedPath,
+            componentKey: localEntry?.componentKey
+                ?? remoteEntry?.componentKey
+                ?? trackedEntry?.componentKey
+                ?? deriveComponentKey(trackedPath),
+            syncStatus: determineSyncStatus({
+                localHash,
+                remoteHash,
+                lastSyncedHash,
+            }),
+            driftStatus: baselineHash
+                ? baselineHash === remoteHash ? 'in-sync' : 'drifted'
+                : 'baseline-missing',
+            localHash,
+            remoteHash,
+            lastSyncedHash,
+            baselineHash,
+        });
+    }
+    return statuses;
+}
+function writeTrackedSourceFile(baseDir, trackedPath, content) {
+    const absolutePath = resolveTrackedFilePath(baseDir, trackedPath);
+    fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+    fs.writeFileSync(absolutePath, content, 'utf-8');
+}
+function deleteTrackedSourceFile(baseDir, trackedPath) {
+    const absolutePath = resolveTrackedFilePath(baseDir, trackedPath);
+    if (!fs.existsSync(absolutePath)) {
+        return;
+    }
+    fs.rmSync(absolutePath);
+}
+function syncTrackingWithStatus(input) {
+    const baseDir = input.baseDir ?? '.';
+    const tracking = loadTrackingData(baseDir);
+    const localEntries = new Map(collectLocalSourceEntries(baseDir).map((entry) => [entry.path, entry]));
+    const remoteEntries = new Map(input.status.files.map((file) => [file.path, file]));
+    const baselineEntries = new Map(input.status.baselineFiles.map((file) => [file.path, file]));
+    for (const trackedPath of input.targetPaths) {
+        const localEntry = localEntries.get(trackedPath);
+        const remoteEntry = remoteEntries.get(trackedPath);
+        const baselineEntry = baselineEntries.get(trackedPath);
+        const localHash = localEntry?.hash ?? '';
+        const remoteHash = remoteEntry?.hash ?? '';
+        if (!localHash && !remoteHash) {
+            delete tracking.files[trackedPath];
+            continue;
+        }
+        tracking.files[trackedPath] = {
+            componentKey: localEntry?.componentKey
+                ?? remoteEntry?.componentKey
+                ?? deriveComponentKey(trackedPath),
+            track: localEntry?.track
+                ?? remoteEntry?.track
+                ?? tracking.files[trackedPath]?.track
+                ?? inferTrackFromPath(trackedPath),
+            localHash,
+            remoteHash,
+            lastSyncedHash: remoteHash || localHash,
+            baselineHash: baselineEntry?.hash ?? null,
+        };
+    }
+    tracking.schemaVersion = TRACKING_SCHEMA_VERSION;
+    tracking.workspaceRoot = '.';
+    tracking.lastSync = {
+        remoteRevision: input.status.remoteRevision,
+        baselineRevision: input.status.baselineRevision ?? null,
+        syncedAt: input.syncedAt ?? new Date().toISOString(),
+    };
+    saveTrackingData(baseDir, tracking);
+}
+function filterByMetadataSelector(statuses, selectors) {
+    if (selectors.length === 0) {
+        return statuses;
+    }
+    const parsed = selectors.map((selector) => {
+        const colonIndex = selector.indexOf(':');
+        if (colonIndex === -1) {
+            return { type: selector.toLowerCase(), name: undefined };
+        }
+        return {
+            type: selector.slice(0, colonIndex).toLowerCase(),
+            name: selector.slice(colonIndex + 1),
+        };
+    });
+    return statuses.filter((entry) => {
+        const keyColonIndex = entry.componentKey.indexOf(':');
+        if (keyColonIndex === -1) {
+            return false;
+        }
+        const entryType = entry.componentKey.slice(0, keyColonIndex).toLowerCase();
+        const entryName = entry.componentKey.slice(keyColonIndex + 1);
+        return parsed.some((selector) => {
+            if (selector.type !== entryType) {
+                return false;
+            }
+            if (selector.name === undefined) {
+                return true;
+            }
+            return selector.name === entryName;
+        });
+    });
+}
+function filterByDirectory(statuses, dirs) {
+    if (dirs.length === 0)
+        return statuses;
+    const normalizedDirs = dirs.map(d => d.endsWith('/') ? d : d + '/');
+    return statuses.filter(entry => normalizedDirs.some(dir => entry.path.startsWith(dir)));
+}
+function refreshTrackingWithRemoteStatus(input) {
+    const baseDir = input.baseDir ?? '.';
+    const tracking = loadTrackingData(baseDir);
+    const remoteEntries = new Map(input.status.files.map((file) => [file.path, file]));
+    const baselineEntries = new Map(input.status.baselineFiles.map((file) => [file.path, file]));
+    const localEntries = new Map(collectLocalSourceEntries(baseDir).map((entry) => [entry.path, entry]));
+    const targetPaths = input.targetPaths?.length
+        ? input.targetPaths
+        : Array.from(new Set([
+            ...Object.keys(tracking.files),
+            ...remoteEntries.keys(),
+            ...baselineEntries.keys(),
+            ...localEntries.keys(),
+        ]));
+    for (const trackedPath of targetPaths) {
+        const existing = tracking.files[trackedPath];
+        const localEntry = localEntries.get(trackedPath);
+        const remoteEntry = remoteEntries.get(trackedPath);
+        const baselineEntry = baselineEntries.get(trackedPath);
+        const localHash = localEntry?.hash ?? existing?.localHash ?? '';
+        const remoteHash = remoteEntry?.hash ?? existing?.remoteHash ?? '';
+        const baselineHash = baselineEntry?.hash ?? existing?.baselineHash ?? null;
+        if (!localHash && !remoteHash && !baselineHash) {
+            delete tracking.files[trackedPath];
+            continue;
+        }
+        tracking.files[trackedPath] = {
+            componentKey: localEntry?.componentKey
+                ?? remoteEntry?.componentKey
+                ?? existing?.componentKey
+                ?? deriveComponentKey(trackedPath),
+            track: localEntry?.track
+                ?? remoteEntry?.track
+                ?? existing?.track
+                ?? inferTrackFromPath(trackedPath),
+            localHash,
+            remoteHash,
+            lastSyncedHash: existing?.lastSyncedHash ?? '',
+            baselineHash,
+        };
+    }
+    tracking.lastSync = {
+        remoteRevision: input.status.remoteRevision,
+        baselineRevision: input.status.baselineRevision ?? null,
+        syncedAt: tracking.lastSync?.syncedAt,
+    };
+    saveTrackingData(baseDir, tracking);
+}
+//# sourceMappingURL=source-tracker.js.map