universal-dev-standards 3.5.1-beta.15 → 3.5.1-beta.17

package/src/utils/hasher.js

@@ -2,6 +2,21 @@ import { createHash } from 'crypto';
 import { readFileSync, statSync, existsSync, readdirSync } from 'fs';
 import { join } from 'path';
 
+/**
+ * Marker block constants for different file formats
+ * (Duplicated from integration-generator.js to avoid circular dependency)
+ */
+const MARKERS = {
+  markdown: {
+    start: '<!-- UDS:STANDARDS:START -->',
+    end: '<!-- UDS:STANDARDS:END -->'
+  },
+  plaintext: {
+    start: '# === UDS:STANDARDS:START ===',
+    end: '# === UDS:STANDARDS:END ==='
+  }
+};
+
 /**
  * Compute SHA-256 hash for a file
  * @param {string} filePath - Absolute file path
@@ -218,3 +233,181 @@ export function scanForUntrackedFiles(projectPath, manifest) {
 
   return untracked;
 }
+
+/**
+ * Detect file format based on file path
+ * @param {string} filePath - File path
+ * @returns {'markdown'|'plaintext'} Format type
+ */
+function detectFormat(filePath) {
+  // Plaintext rules files
+  if (filePath.endsWith('.cursorrules') ||
+      filePath.endsWith('.windsurfrules') ||
+      filePath.endsWith('.clinerules')) {
+    return 'plaintext';
+  }
+  return 'markdown';
+}
+
+/**
+ * Extract content between UDS markers from file content
+ * @param {string} content - File content
+ * @param {'markdown'|'plaintext'} format - Format type
+ * @returns {{before: string, blockContent: string, after: string}} Extracted parts
+ */
+function extractBlockContent(content, format) {
+  const markers = MARKERS[format] || MARKERS.markdown;
+  const startIdx = content.indexOf(markers.start);
+  const endIdx = content.indexOf(markers.end);
+
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+    return { before: content, blockContent: '', after: '' };
+  }
+
+  return {
+    before: content.substring(0, startIdx),
+    blockContent: content.substring(startIdx + markers.start.length, endIdx).trim(),
+    after: content.substring(endIdx + markers.end.length)
+  };
+}
+
+/**
+ * Compute hash for UDS marker block content in an integration file
+ * This only hashes the content between UDS markers, not user customizations outside the block
+ * @param {string} filePath - Absolute file path
+ * @returns {Object|null} { blockHash, blockSize, fullHash, fullSize } or null if file doesn't exist or no markers found
+ */
+export function computeIntegrationBlockHash(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const format = detectFormat(filePath);
+    const { blockContent } = extractBlockContent(content, format);
+
+    // If no markers found, return null (this file may not have UDS markers)
+    if (!blockContent) {
+      return null;
+    }
+
+    const blockHash = createHash('sha256').update(blockContent).digest('hex');
+    const fullHash = createHash('sha256').update(content).digest('hex');
+    const stats = statSync(filePath);
+
+    return {
+      blockHash: `sha256:${blockHash}`,
+      blockSize: Buffer.byteLength(blockContent, 'utf-8'),
+      fullHash: `sha256:${fullHash}`,
+      fullSize: stats.size
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compare integration block hash with stored hash info
+ * @param {string} filePath - Absolute file path
+ * @param {Object} storedInfo - Stored hash info from manifest
+ * @param {string} storedInfo.blockHash - Stored block hash
+ * @param {number} storedInfo.blockSize - Stored block size in bytes
+ * @returns {'unchanged'|'modified'|'missing'|'no_markers'} Block status
+ */
+export function compareIntegrationBlockHash(filePath, storedInfo) {
+  if (!existsSync(filePath)) {
+    return 'missing';
+  }
+
+  const current = computeIntegrationBlockHash(filePath);
+  if (!current) {
+    return 'no_markers';
+  }
+
+  // Compare block hash and size
+  if (current.blockSize !== storedInfo.blockSize) {
+    return 'modified';
+  }
+
+  if (current.blockHash !== storedInfo.blockHash) {
+    return 'modified';
+  }
+
+  return 'unchanged';
+}
+
+/**
+ * Compute hashes for all files in a directory recursively
+ * @param {string} dirPath - Directory to scan
+ * @param {string} baseKey - Base key prefix for hash map entries
+ * @returns {Object} Map of key to { hash, size, installedAt }
+ */
+export function computeDirectoryHashes(dirPath, baseKey = '') {
+  const hashes = {};
+  const now = new Date().toISOString();
+
+  if (!existsSync(dirPath)) {
+    return hashes;
+  }
+
+  const files = scanDirectory(dirPath, dirPath);
+
+  for (const relativePath of files) {
+    const fullPath = join(dirPath, relativePath);
+    const hashInfo = computeFileHash(fullPath);
+
+    if (hashInfo) {
+      // Build key: baseKey/relativePath (using forward slashes for consistency)
+      const key = baseKey ? `${baseKey}/${relativePath}` : relativePath;
+      hashes[key] = {
+        ...hashInfo,
+        installedAt: now
+      };
+    }
+  }
+
+  return hashes;
+}
+
+/**
+ * Compare directory contents against stored hashes
+ * @param {string} dirPath - Directory to check
+ * @param {Object} storedHashes - Map of key to { hash, size }
+ * @param {string} baseKey - Base key prefix used when computing hashes
+ * @returns {Object} { unchanged: [], modified: [], missing: [], added: [] }
+ */
+export function compareDirectoryHashes(dirPath, storedHashes, baseKey = '') {
+  const result = {
+    unchanged: [],
+    modified: [],
+    missing: [],
+    added: []
+  };
+
+  // Get current files
+  const currentHashes = computeDirectoryHashes(dirPath, baseKey);
+  const currentKeys = new Set(Object.keys(currentHashes));
+  const storedKeys = new Set(Object.keys(storedHashes));
+
+  // Check stored files
+  for (const key of storedKeys) {
+    if (!currentKeys.has(key)) {
+      result.missing.push(key);
+    } else {
+      const stored = storedHashes[key];
+      const current = currentHashes[key];
+
+      if (stored.hash === current.hash && stored.size === current.size) {
+        result.unchanged.push(key);
+      } else {
+        result.modified.push(key);
+      }
+    }
+  }
+
+  // Check for added files
+  for (const key of currentKeys) {
+    if (!storedKeys.has(key)) {
+      result.added.push(key);
+    }
+  }
+
+  return result;
+}

package/src/utils/integration-generator.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { dirname, join, basename } from 'path';
 import { getLanguageRules } from '../prompts/integrations.js';
+import { computeIntegrationBlockHash } from './hasher.js';
 
 /**
  * Marker block constants for different file formats
@@ -2026,7 +2027,16 @@ export function writeIntegrationFile(tool, config, projectPath) {
     }
 
     writeFileSync(filePath, content);
-    return { success: true, path: filePath };
+
+    // Compute block hash for tracking UDS content separately from user content
+    const blockHashInfo = computeIntegrationBlockHash(filePath);
+
+    return {
+      success: true,
+      path: fileName, // Return relative path for consistency
+      absolutePath: filePath,
+      blockHashInfo // Contains: blockHash, blockSize, fullHash, fullSize
+    };
   } catch (error) {
     return { success: false, error: error.message };
   }

package/src/utils/skills-installer.js

@@ -15,6 +15,7 @@ import {
   getSkillsDirForAgent,
   getCommandsDirForAgent
 } from '../config/ai-agent-paths.js';
+import { computeDirectoryHashes, computeFileHash } from './hasher.js';
 
 // Get the CLI package root directory
 const __filename = fileURLToPath(import.meta.url);
@@ -132,7 +133,8 @@ export async function installSkillsForAgent(agent, level, skillNames = null, pro
     level,
     targetDir,
     installed: [],
-    errors: []
+    errors: [],
+    fileHashes: {} // New: file hashes for installed skills
   };
 
   for (const skillName of toInstall) {
@@ -148,6 +150,11 @@ export async function installSkillsForAgent(agent, level, skillNames = null, pro
   // Write manifest
   if (results.installed.length > 0) {
     writeSkillsManifestForAgent(agent, level, targetDir);
+
+    // Compute file hashes for tracking
+    // Key format: agent/level/skillName/filename (e.g., "opencode/project/commit-standards/SKILL.md")
+    const baseKey = `${agent}/${level}`;
+    results.fileHashes = computeDirectoryHashes(targetDir, baseKey);
   }
 
   return results;
@@ -266,7 +273,8 @@ export async function installCommandsForAgent(agent, commandNames = null, projec
     agent,
     targetDir,
     installed: [],
-    errors: []
+    errors: [],
+    fileHashes: {} // New: file hashes for installed commands
   };
 
   for (const cmdName of toInstall) {
@@ -282,6 +290,21 @@ export async function installCommandsForAgent(agent, commandNames = null, projec
   // Write manifest
   if (results.installed.length > 0) {
     writeCommandsManifest(agent, targetDir, results.installed);
+
+    // Compute file hashes for tracking
+    // Key format: agent/filename (e.g., "opencode/commit.md")
+    const now = new Date().toISOString();
+    for (const cmdName of results.installed) {
+      const ext = getCommandFileExtension(agent);
+      const filePath = join(targetDir, `${cmdName}${ext}`);
+      const hashInfo = computeFileHash(filePath);
+      if (hashInfo) {
+        results.fileHashes[`${agent}/${cmdName}${ext}`] = {
+          ...hashInfo,
+          installedAt: now
+        };
+      }
+    }
   }
 
   return results;
@@ -615,7 +638,8 @@ export async function installSkillsToMultipleAgents(installations, skillNames =
     success: true,
     installations: [],
     totalInstalled: 0,
-    totalErrors: 0
+    totalErrors: 0,
+    allFileHashes: {} // New: combined file hashes from all installations
   };
 
   for (const { agent, level } of installations) {
@@ -627,6 +651,11 @@ export async function installSkillsToMultipleAgents(installations, skillNames =
     }
     results.totalInstalled += result.installed.length;
     results.totalErrors += result.errors.length;
+
+    // Merge file hashes from this installation
+    if (result.fileHashes) {
+      Object.assign(results.allFileHashes, result.fileHashes);
+    }
   }
 
   return results;
@@ -644,7 +673,8 @@ export async function installCommandsToMultipleAgents(agents, commandNames = nul
     success: true,
     installations: [],
     totalInstalled: 0,
-    totalErrors: 0
+    totalErrors: 0,
+    allFileHashes: {} // New: combined file hashes from all installations
   };
 
   for (const agent of agents) {
@@ -659,6 +689,11 @@ export async function installCommandsToMultipleAgents(agents, commandNames = nul
     }
     results.totalInstalled += result.installed.length;
     results.totalErrors += result.errors.length;
+
+    // Merge file hashes from this installation
+    if (result.fileHashes) {
+      Object.assign(results.allFileHashes, result.fileHashes);
+    }
   }
 
   return results;

package/standards-registry.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "version": "3.5.1-beta.15",
+  "version": "3.5.1-beta.17",
   "lastUpdated": "2026-01-15",
   "description": "Standards registry for universal-dev-standards with integrated skills and AI-optimized formats",
   "formats": {
@@ -48,14 +48,14 @@
     "standards": {
       "name": "universal-dev-standards",
       "url": "https://github.com/AsiaOstrich/universal-dev-standards",
-      "version": "3.5.1-beta.15"
+      "version": "3.5.1-beta.17"
     },
     "skills": {
       "name": "universal-dev-standards",
       "url": "https://github.com/AsiaOstrich/universal-dev-standards",
       "localPath": "skills/claude-code",
       "rawUrl": "https://raw.githubusercontent.com/AsiaOstrich/universal-dev-standards/main/skills/claude-code",
-      "version": "3.5.1-beta.15",
+      "version": "3.5.1-beta.17",
       "note": "Skills are now included in the main repository under skills/"
     }
   },