cowork-flow 0.0.47 → 0.0.49

package/src/lib/copy-template.js

@@ -4,9 +4,8 @@ import { join, relative } from 'node:path';
 
 import { createAssetPlan, planActions } from './asset-plan.js';
 import { hostRegistry } from './host-assets.js';
-import { applyAssetPlan } from './plan-applier.js';
+import { applyAssetPlan, inspectAssetTransactions } from './plan-applier.js';
 import { templateRoot } from './paths.js';
-import { shouldIncludeForPlatforms, skillDestinationForPlatform } from './platforms.js';
 
 async function pathExists(path) {
   try {
@@ -25,10 +24,13 @@ async function listFiles(root, current = root) {
   const files = [];
 
   for (const entry of entries) {
+    if (entry.name === '__pycache__') {
+      continue;
+    }
     const absolute = join(current, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles(root, absolute));
-    } else if (entry.isFile()) {
+    } else if (entry.isFile() && !entry.name.endsWith('.pyc')) {
       files.push(relative(root, absolute));
     }
   }
@@ -91,7 +93,7 @@ async function appendSkillFileActions(actions, {
   for (const skill of await listSkillDirs()) {
     const skillFiles = await listSkillFiles(skill);
     for (const platform of platforms) {
-      const destBase = skillDestinationForPlatform(platform);
+      const destBase = hostRegistry.skillDestination(platform);
       if (!destBase) continue;
       for (const skillFile of skillFiles) {
         const destination = join(
@@ -117,6 +119,67 @@ async function appendSkillFileActions(actions, {
   }
 }
 
+async function appendSkillTargetActions(actions, {
+  targetDir,
+  skillTargets,
+  seen,
+  sync = false
+}) {
+  const normalizedTargets = [...new Set(skillTargets.map(toTemplatePath))].sort();
+  for (const skill of await listSkillDirs()) {
+    const skillFiles = await listSkillFiles(skill);
+    for (const destBase of normalizedTargets) {
+      for (const skillFile of skillFiles) {
+        const destination = join(
+          targetDir,
+          destBase,
+          skill.id,
+          skillFile.skillRelativePath
+        );
+        if (seen.has(destination)) continue;
+        seen.add(destination);
+        const exists = await pathExists(destination);
+        const unchanged = sync && exists
+          ? await sourceMatchesDestination(skillFile.source, destination)
+          : false;
+        actions.push({
+          action: exists ? (sync ? (unchanged ? 'skip' : 'update') : 'skip') : 'create',
+          source: skillFile.source,
+          destination,
+          relativePath: join(destBase, skill.id, skillFile.skillRelativePath)
+        });
+      }
+    }
+  }
+}
+
+function isSourceCheckoutProtected(relativePath) {
+  const normalized = toTemplatePath(relativePath);
+  if (hostRegistry.syncPolicy.protectedFiles.includes(normalized)) {
+    return true;
+  }
+  return hostRegistry.syncPolicy.protectedPrefixes
+    .filter((prefix) => prefix !== '.cowork-flow/spec/')
+    .some((prefix) => normalized.startsWith(prefix))
+    || normalized.startsWith('.cowork-flow/.runtime/');
+}
+
+function shouldIncludeSourceCheckoutRuntimeFile(relativePath) {
+  const normalized = toTemplatePath(relativePath);
+  return normalized.startsWith('.cowork-flow/')
+    && normalized !== '.cowork-flow/.version'
+    && !isSourceCheckoutProtected(normalized);
+}
+
+function isSourceRefreshObsoleteFile(relativePath) {
+  const normalized = toTemplatePath(relativePath);
+  if (isSourceCheckoutProtected(normalized)) {
+    return false;
+  }
+  return normalized.startsWith('.cowork-flow/')
+    || hostRegistry.skillTargets.some((target) => normalized.startsWith(`${target}/`));
+}
+
 export async function buildInitPlan(targetDir, options = {}) {
   const files = await listFiles(templateRoot);
   const actions = [];
@@ -124,7 +187,7 @@ export async function buildInitPlan(targetDir, options = {}) {
   const seen = new Set();
 
   for (const file of files) {
-    if (!shouldIncludeForPlatforms(file, platforms)) {
+    if (!hostRegistry.shouldInclude(file, platforms)) {
       continue;
     }
 
@@ -169,43 +232,9 @@ export async function buildInitPlan(targetDir, options = {}) {
   });
 }
 
-const PROTECTED_SYNC_FILES = new Set(
-  hostRegistry.syncPolicy.protectedFiles
-);
-const PROTECTED_SYNC_PREFIXES = hostRegistry.syncPolicy.protectedPrefixes;
-const SAFE_SYNC_FILES = new Set(hostRegistry.syncPolicy.safeFiles);
-const SAFE_SYNC_PREFIXES = [
-  ...hostRegistry.syncPolicy.safePrefixes,
-  ...hostRegistry.assetPrefixes,
-  ...hostRegistry.skillTargets.map((target) => `${target}/`)
-];
-const MANAGED_BLOCK_FILES = new Set(
-  hostRegistry.syncPolicy.managedBlockFiles
-);
-const OBSOLETE_SYNC_FILES = new Set(
-  hostRegistry.syncPolicy.obsoleteFiles
-);
-
 const COWORK_FLOW_START = '<!-- COWORK-FLOW:START -->';
 const COWORK_FLOW_END = '<!-- COWORK-FLOW:END -->';
 
-function isProtectedSyncFile(relativePath) {
-  const templatePath = toTemplatePath(relativePath);
-  if (SAFE_SYNC_FILES.has(templatePath)) {
-    return false;
-  }
-  return PROTECTED_SYNC_FILES.has(templatePath)
-    || PROTECTED_SYNC_PREFIXES.some((prefix) => templatePath.startsWith(prefix));
-}
-
-function isSafeSyncFile(relativePath) {
-  const templatePath = toTemplatePath(relativePath);
-  return SAFE_SYNC_FILES.has(templatePath)
-    || SAFE_SYNC_PREFIXES.some((prefix) => templatePath.startsWith(prefix))
-    || hostRegistry.isKnownPlatformAsset(templatePath)
-    || templatePath.endsWith('/.gitkeep');
-}
-
 function isCoveredByDeletedParent(relativePath, deletedParents) {
   return deletedParents.some((parent) => relativePath.startsWith(`${parent}/`));
 }
@@ -265,6 +294,71 @@ async function buildFileSyncAction({ source, destination, relativePath }) {
   };
 }
 
+export async function buildSourceCheckoutRefreshPlan(targetDir, options = {}) {
+  const files = await listFiles(templateRoot);
+  const actions = [];
+  const seen = new Set();
+
+  for (const file of files) {
+    const templatePath = toTemplatePath(file);
+    if (!shouldIncludeSourceCheckoutRuntimeFile(templatePath)) {
+      continue;
+    }
+    const source = join(templateRoot, file);
+    const destination = join(targetDir, file);
+    seen.add(destination);
+    const exists = await pathExists(destination);
+    if (!exists) {
+      actions.push({ action: 'create', source, destination, relativePath: file });
+      continue;
+    }
+    actions.push(await buildFileSyncAction({
+      source,
+      destination,
+      relativePath: file
+    }));
+  }
+
+  await appendSkillTargetActions(actions, {
+    targetDir,
+    skillTargets: options.skillTargets ?? hostRegistry.skillTargets,
+    seen,
+    sync: true
+  });
+
+  const deletedObsoleteParents = [];
+  for (const file of hostRegistry.obsoleteSyncFiles()) {
+    if (!isSourceRefreshObsoleteFile(file) || isCoveredByDeletedParent(file, deletedObsoleteParents)) {
+      continue;
+    }
+    const destination = join(targetDir, file);
+    if (await pathExists(destination)) {
+      deletedObsoleteParents.push(file);
+      actions.push({ action: 'delete', source: null, destination, relativePath: file });
+    }
+  }
+
+  const versionDestination = join(targetDir, '.cowork-flow', '.version');
+  const versionSource = join(templateRoot, '.cowork-flow', '.version');
+  const versionContent = await readFile(versionSource, 'utf8');
+  const versionExists = await pathExists(versionDestination);
+  const versionUnchanged = versionExists
+    && (await readFile(versionDestination, 'utf8')) === versionContent;
+  actions.push({
+    action: versionExists ? (versionUnchanged ? 'skip' : 'update') : 'create',
+    source: null,
+    destination: versionDestination,
+    relativePath: '.cowork-flow/.version',
+    content: versionContent
+  });
+
+  return createAssetPlan({
+    kind: 'source-refresh',
+    targetDir,
+    actions
+  });
+}
+
 export async function buildSyncPlan(targetDir, options = {}) {
   if (!await pathExists(join(targetDir, '.cowork-flow'))) {
     throw new Error(`Target is not initialized: ${targetDir}`);
@@ -276,7 +370,7 @@ export async function buildSyncPlan(targetDir, options = {}) {
   const seen = new Set();
 
   for (const file of files) {
-    if (!shouldIncludeForPlatforms(file, platforms)) {
+    if (!hostRegistry.shouldInclude(file, platforms)) {
       continue;
     }
 
@@ -289,13 +383,13 @@ export async function buildSyncPlan(targetDir, options = {}) {
 
     const source = join(templateRoot, file);
     const exists = await pathExists(destination);
-    if (MANAGED_BLOCK_FILES.has(toTemplatePath(file))) {
+    if (hostRegistry.isManagedBlockFile(file)) {
       actions.push(await buildManagedBlockSyncAction({ source, destination, exists, options, relativePath: file }));
       continue;
     }
 
-    const protectedFile = isProtectedSyncFile(file) && !options.force && exists;
-    const safeFile = isSafeSyncFile(file);
+    const protectedFile = hostRegistry.isProtectedSyncFile(file) && !options.force && exists;
+    const safeFile = hostRegistry.isSafeSyncFile(file);
 
     if (protectedFile) {
       actions.push({ action: 'protected', source, destination, relativePath: file });
@@ -315,13 +409,7 @@ export async function buildSyncPlan(targetDir, options = {}) {
   await appendSkillFileActions(actions, { targetDir, platforms, seen, sync: true });
 
   const deletedObsoleteParents = [];
-  const obsoleteFiles = [...OBSOLETE_SYNC_FILES].sort((left, right) => {
-    if (left.length !== right.length) {
-      return left.length - right.length;
-    }
-    return left.localeCompare(right);
-  });
-  for (const file of obsoleteFiles) {
+  for (const file of hostRegistry.obsoleteSyncFiles()) {
     if (isCoveredByDeletedParent(file, deletedObsoleteParents)) {
       continue;
     }
@@ -355,6 +443,68 @@ export async function detectInstalledPlatforms(targetDir) {
   return hostRegistry.detectInstalledPlatforms(targetDir, pathExists);
 }
 
+function normalizeReportPath(value) {
+  return String(value).replaceAll('\\', '/');
+}
+
+function hostAssetOwners(relativePath) {
+  const normalized = normalizeReportPath(relativePath);
+  const owners = new Set(hostRegistry.assetOwners(normalized));
+  for (const platform of hostRegistry.platforms) {
+    const skillTarget = platform.skillTarget ? normalizeReportPath(platform.skillTarget) : null;
+    if (skillTarget && normalized.startsWith(`${skillTarget}/`)) {
+      owners.add(platform.id);
+    }
+  }
+  return [...owners];
+}
+
+function readinessAction(action) {
+  const item = { path: action.relativePath, action: action.action };
+  const platforms = hostAssetOwners(action.relativePath);
+  if (platforms.length > 0) {
+    item.platforms = platforms;
+  }
+  return item;
+}
+
+function recoveryWarning(transaction) {
+  if (transaction.error) {
+    return `pending recovery metadata unreadable at ${transaction.path}: ${transaction.error}`;
+  }
+  if (transaction.status === 'committed') {
+    return `stale committed transaction cleanup pending at ${transaction.path}`;
+  }
+  return `pending ${transaction.status} transaction recovery at ${transaction.path}`;
+}
+
+export async function buildReadinessReport(plan, options = {}) {
+  const actions = planActions(plan);
+  const pendingRecovery = await inspectAssetTransactions(plan.targetDir, {
+    fileSystem: options.fileSystem
+  });
+  return {
+    wouldCopy: actions
+      .filter((action) => action.action === 'create' || action.action === 'update')
+      .map(readinessAction),
+    wouldSkipProtected: actions
+      .filter((action) => action.action === 'protected')
+      .map(readinessAction),
+    wouldRemoveObsolete: actions
+      .filter((action) => action.action === 'delete')
+      .map(readinessAction),
+    hostAssetRefresh: actions
+      .filter((action) => action.action !== 'skip' && hostAssetOwners(action.relativePath).length > 0)
+      .map(readinessAction),
+    pendingRecovery,
+    warnings: pendingRecovery.map(recoveryWarning)
+  };
+}
+
+export function formatReadinessReport(report) {
+  return `readiness=${JSON.stringify(report)}\n`;
+}
+
 export function summarizePlan(plan, dryRun = false) {
   const actions = planActions(plan);
   const counts = { create: 0, update: 0, skip: 0, protected: 0, delete: 0 };