@sylphx/flow 1.4.11 → 1.4.13

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @sylphx/flow
 
+## 1.4.13
+
+### Patch Changes
+
+- 1d0ac4e: Add startup check for new templates:
+  - Detects missing templates on startup (new templates not installed locally)
+  - Shows notification with count of new agents/commands/rules
+  - Prompts user to run --sync to install
+  - Ignores unknown files (custom user files)
+  - Non-blocking - just informational
+
+## 1.4.12
+
+### Patch Changes
+
+- d88d280: Show missing templates in sync preview:
+  - Added "Will install (new templates)" section
+  - Users can now see which templates will be newly installed
+  - Better visibility into what changes sync will make
+
 ## 1.4.11
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylphx/flow",
-  "version": "1.4.11",
+  "version": "1.4.13",
   "description": "AI-powered development workflow automation with autonomous loop mode and smart configuration",
   "type": "module",
   "bin": {

package/src/commands/flow-command.ts

@@ -621,6 +621,7 @@ async function executeFlowOnce(prompt: string | undefined, options: FlowOptions)
   const {
     checkUpgrades,
     checkComponentIntegrity,
+    checkSyncStatus,
     selectTarget,
     initializeProject,
     launchTarget,
@@ -675,6 +676,9 @@ async function executeFlowOnce(prompt: string | undefined, options: FlowOptions)
 
     // Step 2.5: Check component integrity (only if we have valid state)
     await checkComponentIntegrity(state, options);
+
+    // Step 2.6: Check sync status (new templates available)
+    await checkSyncStatus(state, options);
   }
 
   // Step 3: Initialize (only if actually needed)

package/src/commands/flow-orchestrator.ts

@@ -147,6 +147,59 @@ export async function checkComponentIntegrity(
   }
 }
 
+/**
+ * Step 2.5: Check sync status (new templates available)
+ * Only checks for missing templates, ignores unknown files
+ */
+export async function checkSyncStatus(
+  state: ProjectState,
+  options: FlowOptions
+): Promise<void> {
+  // Skip if not initialized, syncing, or init-only
+  if (!state.initialized || options.sync || options.initOnly) return;
+
+  // Skip in quick mode
+  if (options.quick) return;
+
+  // Need target to check sync status
+  if (!state.target) return;
+
+  try {
+    const { buildSyncManifest } = await import('../utils/sync-utils.js');
+    const target = targetManager.getTarget(state.target);
+
+    if (target._tag === 'None') return;
+
+    const manifest = await buildSyncManifest(process.cwd(), target.value);
+
+    // Count missing templates (new templates not installed locally)
+    const missingCount =
+      manifest.agents.missing.length +
+      manifest.slashCommands.missing.length +
+      manifest.rules.missing.length;
+
+    // Only prompt if there are missing templates
+    if (missingCount > 0) {
+      const missing: string[] = [];
+
+      if (manifest.agents.missing.length > 0) {
+        missing.push(`${manifest.agents.missing.length} agent${manifest.agents.missing.length > 1 ? 's' : ''}`);
+      }
+      if (manifest.slashCommands.missing.length > 0) {
+        missing.push(`${manifest.slashCommands.missing.length} command${manifest.slashCommands.missing.length > 1 ? 's' : ''}`);
+      }
+      if (manifest.rules.missing.length > 0) {
+        missing.push(`${manifest.rules.missing.length} rule${manifest.rules.missing.length > 1 ? 's' : ''}`);
+      }
+
+      console.log(chalk.yellow(`\n📦 New templates available: ${missing.join(', ')}\n`));
+      console.log(chalk.dim(`   Run ${chalk.cyan('sylphx-flow --sync')} to install new templates\n`));
+    }
+  } catch (error) {
+    // Silently ignore sync check errors - don't block execution
+  }
+}
+
 /**
  * Step 3: Handle target selection
  * Returns the selected target ID

package/src/utils/sync-utils.ts

@@ -31,8 +31,9 @@ const FLOW_RULES = scanTemplateDir(getRulesDir());
  * Categorized files for sync
  */
 interface CategorizedFiles {
-  inFlow: string[];      // Files that exist in Flow templates
+  inFlow: string[];      // Files that exist locally and in Flow templates (will reinstall)
   unknown: string[];     // Files not in Flow templates (custom or removed)
+  missing: string[];     // Flow templates that don't exist locally (will install)
 }
 
 /**
@@ -50,11 +51,15 @@ interface SyncManifest {
 }
 
 /**
- * Categorize files into Flow templates vs unknown
+ * Categorize files into Flow templates vs unknown, and detect missing templates
  */
 function categorizeFiles(files: string[], flowTemplates: string[]): CategorizedFiles {
   const inFlow: string[] = [];
   const unknown: string[] = [];
+  const existingBasenames = files.map((f) => path.basename(f));
+
+  // Find missing Flow templates (in flowTemplates but not in files)
+  const missing = flowTemplates.filter((template) => !existingBasenames.includes(template));
 
   for (const file of files) {
     const basename = path.basename(file);
@@ -65,7 +70,7 @@ function categorizeFiles(files: string[], flowTemplates: string[]): CategorizedF
     }
   }
 
-  return { inFlow, unknown };
+  return { inFlow, unknown, missing };
 }
 
 /**
@@ -73,9 +78,9 @@ function categorizeFiles(files: string[], flowTemplates: string[]): CategorizedF
  */
 export async function buildSyncManifest(cwd: string, target: Target): Promise<SyncManifest> {
   const manifest: SyncManifest = {
-    agents: { inFlow: [], unknown: [] },
-    slashCommands: { inFlow: [], unknown: [] },
-    rules: { inFlow: [], unknown: [] },
+    agents: { inFlow: [], unknown: [], missing: [] },
+    slashCommands: { inFlow: [], unknown: [], missing: [] },
+    rules: { inFlow: [], unknown: [], missing: [] },
     mcpServers: { inRegistry: [], notInRegistry: [] },
     preserve: [],
   };
@@ -214,6 +219,40 @@ export function showSyncPreview(manifest: SyncManifest, cwd: string): void {
     }
   }
 
+  // Missing templates section (will be installed)
+  const hasMissingFiles =
+    manifest.agents.missing.length > 0 ||
+    manifest.slashCommands.missing.length > 0 ||
+    manifest.rules.missing.length > 0;
+
+  if (hasMissingFiles) {
+    console.log(chalk.green('Will install (new templates):\n'));
+
+    if (manifest.agents.missing.length > 0) {
+      console.log(chalk.dim('  Agents:'));
+      manifest.agents.missing.forEach((file) => {
+        console.log(chalk.dim(`    + ${file}`));
+      });
+      console.log('');
+    }
+
+    if (manifest.slashCommands.missing.length > 0) {
+      console.log(chalk.dim('  Commands:'));
+      manifest.slashCommands.missing.forEach((file) => {
+        console.log(chalk.dim(`    + ${file}`));
+      });
+      console.log('');
+    }
+
+    if (manifest.rules.missing.length > 0) {
+      console.log(chalk.dim('  Rules:'));
+      manifest.rules.missing.forEach((file) => {
+        console.log(chalk.dim(`    + ${file}`));
+      });
+      console.log('');
+    }
+  }
+
   // Unknown files section
   const hasUnknownFiles =
     manifest.agents.unknown.length > 0 ||