@sylphx/flow 1.1.1 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @sylphx/flow
 
+## 1.2.0
+
+### Minor Changes
+
+- 2272596: Enhanced agent system prompts with Minimal Effective Prompt principles:
+
+  - **Workflow Standards**: Added continuous atomic commits, semver discipline (minor-first), TypeScript release workflow with changeset + CI, and proactive pre-commit cleanup
+  - **Research-First Mindset**: Enforced research before implementation to prevent outdated approaches
+  - **Silent Mode Fix**: Prevented agents from creating report files to compensate for not speaking
+  - **Proactive Cleanup**: Added mandatory pre-commit hygiene - refactor, remove unused code, delete outdated docs, fix tech debt
+  - **MEP Refactor**: Refactored all prompts (coder, orchestrator, reviewer, writer, core, code-standards, silent) using Minimal Effective Prompt principles - trust LLM, WHAT+WHEN not HOW+WHY, condition→action format, ~40% token reduction
+
+  Prime directive: Never accumulate misleading artifacts. Research is mandatory. Tests and benchmarks required (.test.ts, .bench.ts).
+
 ## 1.1.1
 
 ### Patch Changes

package/package.json

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

package/src/commands/hook-command.ts

@@ -1,21 +1,17 @@
 #!/usr/bin/env node
 /**
- * Hook command - Dynamic content loading for Claude Code hooks
+ * Hook command - OS notification for Claude Code startup
  *
- * Purpose: Load rules and output styles dynamically via session hooks
- * instead of installing them as static files
+ * Purpose: Send OS-level notifications when Claude Code starts
  *
  * DESIGN RATIONALE:
- * - Single source of truth: assets/ directory
- * - Dynamic loading: No static file maintenance
- * - Flexible: Easy to extend for different hook types and targets
- * - Consistent: Follows sysinfo command pattern
+ * - Simple notification: Just notify user when Claude Code is ready
+ * - Cross-platform: Supports macOS, Linux, and Windows
+ * - Non-intrusive: Fails silently if notification system not available
  */
 
 import { exec } from 'node:child_process';
-import fsSync from 'node:fs';
 import os from 'node:os';
-import path from 'node:path';
 import { promisify } from 'node:util';
 import { Command } from 'commander';
 import { cli } from '../utils/cli-output.js';
@@ -25,7 +21,7 @@ const execAsync = promisify(exec);
 /**
  * Hook types supported
  */
-type HookType = 'session' | 'message' | 'notification';
+type HookType = 'notification';
 
 /**
  * Target platforms supported
@@ -37,7 +33,7 @@ type TargetPlatform = 'claude-code';
  */
 export const hookCommand = new Command('hook')
   .description('Load dynamic system information for Claude Code hooks')
-  .requiredOption('--type <type>', 'Hook type (session, message)')
+  .requiredOption('--type <type>', 'Hook type (notification)')
   .option('--target <target>', 'Target platform (claude-code)', 'claude-code')
   .option('--verbose', 'Show verbose output', false)
   .action(async (options) => {
@@ -46,10 +42,8 @@ export const hookCommand = new Command('hook')
       const target = options.target as TargetPlatform;
 
       // Validate hook type
-      if (!['session', 'message', 'notification'].includes(hookType)) {
-        throw new Error(
-          `Invalid hook type: ${hookType}. Must be 'session', 'message', or 'notification'`
-        );
+      if (hookType !== 'notification') {
+        throw new Error(`Invalid hook type: ${hookType}. Must be 'notification'`);
       }
 
       // Validate target
@@ -83,17 +77,9 @@ export const hookCommand = new Command('hook')
  */
 async function loadHookContent(
   hookType: HookType,
-  target: TargetPlatform,
+  _target: TargetPlatform,
   verbose: boolean = false
 ): Promise<string> {
-  if (hookType === 'session') {
-    return await loadSessionContent(target, verbose);
-  }
-
-  if (hookType === 'message') {
-    return await loadMessageContent(target, verbose);
-  }
-
   if (hookType === 'notification') {
     return await sendNotification(verbose);
   }
@@ -101,212 +87,6 @@ async function loadHookContent(
   return '';
 }
 
-/**
- * Load content for session start hook
- * Includes: system info only (rules and output styles are static files)
- */
-async function loadSessionContent(_target: TargetPlatform, verbose: boolean): Promise<string> {
-  // Load system info for session
-  if (verbose) {
-    cli.info('Loading system info...');
-  }
-  return await getSystemInfo('session');
-}
-
-/**
- * Load content for message hook
- * Includes: system status
- */
-async function loadMessageContent(_target: TargetPlatform, verbose: boolean): Promise<string> {
-  if (verbose) {
-    cli.info('Loading system status...');
-  }
-  return await getSystemInfo('message');
-}
-
-/**
- * Get system information
- */
-async function getSystemInfo(hookType: 'session' | 'message'): Promise<string> {
-  const currentTime = new Date().toISOString();
-  const tempDir = os.tmpdir();
-
-  // Get memory information
-  const totalMem = os.totalmem();
-  const freeMem = os.freemem();
-  const usedMem = totalMem - freeMem;
-  const memoryUsage = ((usedMem / totalMem) * 100).toFixed(1);
-
-  // Get CPU information
-  const cpus = os.cpus();
-  const cpuCores = cpus.length;
-
-  // Get CPU usage (using load average for fast detection)
-  const loadAvg = os.loadavg();
-  const cpuUsagePercent = Math.round((loadAvg[0] / cpuCores) * 100);
-
-  // Get platform information
-  const platform = os.platform();
-  const arch = os.arch();
-
-  if (hookType === 'session') {
-    // Session info includes project information
-    const projectInfo = await detectProjectInfo();
-
-    return `## Session Information
-
-**Platform:** ${platform} (${arch})
-**Working Directory:** ${process.cwd()}
-**Temp Directory:** ${tempDir}
-**CPU:** ${cpuCores} cores
-**Total Memory:** ${formatBytes(totalMem)}
-
-## Project Information
-
-**Project Type:** ${projectInfo.type}
-**Package Manager:** ${projectInfo.packageManager}${
-      projectInfo.name && projectInfo.name !== 'unnamed'
-        ? `\n**Project:** ${projectInfo.name} (${projectInfo.version})`
-        : ''
-    }`;
-  }
-
-  // Message info - just current status
-  return `## System Status
-
-**Current Time:** ${new Date(currentTime).toLocaleString()}
-**CPU:** ${cpuUsagePercent}%
-**Memory:** ${memoryUsage}% used (${formatBytes(freeMem)} free)`;
-}
-
-/**
- * Detect project information
- */
-async function detectProjectInfo() {
-  const cwd = process.cwd();
-  const packageJsonPath = path.join(cwd, 'package.json');
-
-  // Check if package.json exists
-  if (!fsSync.existsSync(packageJsonPath)) {
-    return {
-      type: 'unknown',
-      packageManager: 'none',
-      description: 'No package.json found',
-    };
-  }
-
-  try {
-    // Read package.json
-    const packageJson = JSON.parse(fsSync.readFileSync(packageJsonPath, 'utf8'));
-
-    // Detect project type based on dependencies and scripts
-    const projectType = detectProjectType(packageJson);
-
-    // Detect package manager based on package.json field, then lock files
-    const packageManager = detectPackageManager(cwd, packageJson);
-
-    return {
-      type: projectType,
-      packageManager: packageManager,
-      name: packageJson.name || 'unnamed',
-      version: packageJson.version || '0.0.0',
-      description: packageJson.description || '',
-    };
-  } catch (_error) {
-    return {
-      type: 'js/ts',
-      packageManager: 'unknown',
-      description: 'Invalid package.json',
-    };
-  }
-}
-
-/**
- * Detect project type from package.json
- */
-function detectProjectType(packageJson: Record<string, unknown>): string {
-  // Check for TypeScript
-  const hasTypescript =
-    packageJson.devDependencies?.typescript ||
-    packageJson.dependencies?.typescript ||
-    packageJson.devDependencies?.['@types/node'] ||
-    packageJson.scripts?.build?.includes('tsc') ||
-    packageJson.scripts?.dev?.includes('ts-node');
-
-  if (hasTypescript) {
-    return 'typescript';
-  }
-
-  // Check for React
-  const hasReact =
-    packageJson.dependencies?.react ||
-    packageJson.devDependencies?.react ||
-    packageJson.scripts?.dev?.includes('vite') ||
-    packageJson.scripts?.build?.includes('vite');
-
-  if (hasReact) {
-    return 'react';
-  }
-
-  // Check for Next.js
-  const hasNext =
-    packageJson.dependencies?.next ||
-    packageJson.devDependencies?.next ||
-    packageJson.scripts?.dev === 'next dev' ||
-    packageJson.scripts?.build === 'next build';
-
-  if (hasNext) {
-    return 'next.js';
-  }
-
-  // Default to JavaScript
-  return 'javascript';
-}
-
-/**
- * Detect package manager from lock files
- */
-function detectPackageManager(cwd: string, packageJson?: any): string {
-  // First, check package.json for explicit packageManager field (most accurate)
-  if (packageJson?.packageManager) {
-    const packageManagerField = packageJson.packageManager;
-    // Extract manager name from "bun@1.3.1" format
-    const managerName = packageManagerField.split('@')[0];
-    if (['npm', 'yarn', 'pnpm', 'bun'].includes(managerName)) {
-      return managerName;
-    }
-  }
-
-  // Fallback: Check for lock files in order of preference
-  const lockFiles = [
-    { file: 'pnpm-lock.yaml', manager: 'pnpm' },
-    { file: 'yarn.lock', manager: 'yarn' },
-    { file: 'package-lock.json', manager: 'npm' },
-    { file: 'bun.lockb', manager: 'bun' },
-  ];
-
-  for (const { file, manager } of lockFiles) {
-    if (fsSync.existsSync(path.join(cwd, file))) {
-      return manager;
-    }
-  }
-
-  return 'npm'; // Default to npm
-}
-
-/**
- * Format bytes to human-readable string
- */
-function formatBytes(bytes: number): string {
-  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
-  if (bytes === 0) {
-    return '0 Bytes';
-  }
-
-  const i = Math.floor(Math.log(bytes) / Math.log(1024));
-  return `${Math.round((bytes / 1024 ** i) * 100) / 100} ${sizes[i]}`;
-}
-
 /**
  * Send OS-level notification
  */

package/src/composables/index.ts

@@ -2,4 +2,3 @@
 
 export { useEnv, useEnvVar } from './useEnv.js';
 export { useIsCI, useIsDebug, useRuntimeConfig } from './useRuntimeConfig.js';
-export { useTargetConfig, useTargetConfigById } from './useTargetConfig.js';

package/src/config/servers.ts

@@ -1,5 +1,4 @@
 import type { MCPServerConfigUnion } from '../types.js';
-import { envSecurity, securitySchemas } from '../utils/security.js';
 
 /**
  * Central MCP server registry for Sylphx Flow
@@ -44,83 +43,6 @@ export interface MCPServerDefinition {
  * This replaces all hardcoded server lists throughout the codebase
  */
 export const MCP_SERVER_REGISTRY: Record<string, MCPServerDefinition> = {
-  'sylphx-flow': {
-    id: 'sylphx-flow',
-    name: 'sylphx-flow',
-    description: 'Sylphx Flow MCP server for agent coordination and memory management',
-    config: {
-      type: 'stdio' as const,
-      command: 'sylphx-flow',
-      args: ['mcp', 'start'],
-      env: {
-        OPENAI_API_KEY: '',
-        OPENAI_BASE_URL: 'https://api.openai.com/v1',
-        EMBEDDING_MODEL: 'text-embedding-3-small',
-      },
-    },
-    envVars: {
-      OPENAI_API_KEY: {
-        description: 'OpenAI API key for vector search embeddings',
-        required: false,
-        secret: true,
-      },
-      OPENAI_BASE_URL: {
-        description: 'Base URL for OpenAI-compatible embedding API',
-        required: false,
-        default: 'https://api.openai.com/v1',
-      },
-      EMBEDDING_MODEL: {
-        description: 'Embedding model to use for vector search',
-        required: false,
-        default: 'text-embedding-3-small',
-        dependsOn: ['OPENAI_API_KEY', 'OPENAI_BASE_URL'],
-        fetchChoices: async () => {
-          // Validate environment variables
-          const validatedBaseUrl = envSecurity.getEnvVar(
-            'OPENAI_BASE_URL',
-            'https://api.openai.com/v1'
-          );
-          const validatedApiKey = envSecurity.getEnvVar('OPENAI_API_KEY');
-
-          if (!validatedApiKey) {
-            throw new Error('OPENAI_API_KEY is required to fetch embedding models');
-          }
-
-          // Additional validation for API key format
-          try {
-            securitySchemas.apiKey.parse(validatedApiKey);
-          } catch (_error) {
-            throw new Error('Invalid OPENAI_API_KEY format');
-          }
-
-          const response = await fetch(`${validatedBaseUrl}/models`, {
-            headers: { Authorization: `Bearer ${validatedApiKey}` },
-            timeout: 10000, // Add timeout to prevent hanging
-          });
-
-          if (!response.ok) {
-            throw new Error(`Failed to fetch models: ${response.statusText}`);
-          }
-
-          const data = await response.json();
-          const embeddingModels = data.data
-            .filter((m: { id: string }) => m.id.includes('embedding'))
-            .map((m: { id: string }) => m.id)
-            .sort();
-
-          if (embeddingModels.length === 0) {
-            throw new Error('No embedding models found');
-          }
-
-          return embeddingModels;
-        },
-      },
-    },
-    category: 'core',
-    defaultInInit: true,
-    required: true,
-  },
-
   'gpt-image': {
     id: 'gpt-image',
     name: 'gpt-image-1-mcp',
@@ -219,6 +141,41 @@ export const MCP_SERVER_REGISTRY: Record<string, MCPServerDefinition> = {
     category: 'external',
     defaultInInit: true,
   },
+
+  coderag: {
+    id: 'coderag',
+    name: 'coderag',
+    description: 'CodeRAG - Lightning-fast hybrid code search (TF-IDF + Vector) for RAG',
+    config: {
+      type: 'stdio' as const,
+      command: 'npx',
+      args: ['-y', '@sylphx/coderag-mcp'],
+      env: {
+        OPENAI_API_KEY: '',
+        CODEBASE_ROOT: '',
+        INDEX_PATH: '.coderag',
+      },
+    },
+    envVars: {
+      OPENAI_API_KEY: {
+        description: 'OpenAI API key for embeddings (vector search)',
+        required: false,
+        secret: true,
+      },
+      CODEBASE_ROOT: {
+        description: 'Root directory of codebase to index',
+        required: false,
+        default: '.',
+      },
+      INDEX_PATH: {
+        description: 'Path to store index files',
+        required: false,
+        default: '.coderag',
+      },
+    },
+    category: 'core',
+    defaultInInit: true,
+  },
 };
 
 /**

package/src/core/interfaces.ts

@@ -46,39 +46,6 @@ export interface IStorage<T = unknown> {
   healthCheck(): Promise<{ healthy: boolean; error?: string }>;
 }
 
-// Search service interface
-export interface ISearchService {
-  initialize(): Promise<void>;
-  searchCodebase(query: string, options?: SearchOptions): Promise<SearchResult[]>;
-  searchKnowledge(query: string, options?: SearchOptions): Promise<SearchResult[]>;
-  getStatus(): Promise<SearchServiceStatus>;
-}
-
-// Search options
-export interface SearchOptions {
-  limit?: number;
-  offset?: number;
-  filters?: Record<string, unknown>;
-  sortBy?: string;
-  sortOrder?: 'asc' | 'desc';
-}
-
-// Search result
-export interface SearchResult {
-  id: string;
-  content: string;
-  score: number;
-  metadata: Record<string, unknown>;
-}
-
-// Search service status
-export interface SearchServiceStatus {
-  indexed: number;
-  total: number;
-  lastIndexed: string;
-  healthy: boolean;
-}
-
 // Target manager interface
 export interface ITargetManager {
   getTarget(id: string): Target | null;

package/src/domains/index.ts

@@ -3,6 +3,4 @@
  * Unified exports for all domain modules
  */
 
-export * from './codebase/index.js';
-export * from './knowledge/index.js';
 export * from './utilities/index.js';

package/src/index.ts

@@ -8,9 +8,7 @@ import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
-import { codebaseCommand } from './commands/codebase-command.js';
 import { hookCommand } from './commands/hook-command.js';
-import { knowledgeCommand } from './commands/knowledge-command.js';
 import {
   flowCommand,
   statusCommand,
@@ -95,8 +93,6 @@ export function createCLI(): Command {
   program.addCommand(statusCommand);
   program.addCommand(doctorCommand);
   program.addCommand(upgradeCommand);
-  program.addCommand(codebaseCommand);
-  program.addCommand(knowledgeCommand);
   program.addCommand(hookCommand);
 
   return program;

package/src/services/mcp-service.ts

@@ -293,22 +293,6 @@ export const createMCPService = (deps: MCPServiceDeps): MCPService => {
             ? await resolveConfig(server.config.command)
             : undefined;
           resolvedArgs = server.config.args ? await resolveConfig(server.config.args) : [];
-
-          // Apply target-specific flags for sylphx-flow server
-          if (serverId === 'sylphx-flow' && Array.isArray(resolvedArgs)) {
-            const targetConfig = deps.target.mcpServerConfig;
-            if (targetConfig) {
-              if (targetConfig.disableTime) {
-                resolvedArgs.push('--disable-time');
-              }
-              if (targetConfig.disableKnowledge) {
-                resolvedArgs.push('--disable-knowledge');
-              }
-              if (targetConfig.disableCodebase) {
-                resolvedArgs.push('--disable-codebase');
-              }
-            }
-          }
         }
 
         // Update the config with resolved values (only for CLI servers)

package/src/targets/claude-code.ts

@@ -22,12 +22,6 @@ export const claudeCodeTarget: Target = {
   isImplemented: true,
   isDefault: false,
 
-  mcpServerConfig: {
-    disableTime: true,
-    disableKnowledge: false,
-    disableCodebase: true,
-  },
-
   config: {
     agentDir: '.claude/agents',
     agentExtension: '.md',
@@ -424,10 +418,10 @@ Please begin your response with a comprehensive summary of all the instructions
       throw new Error(`Failed to write settings: ${writeResult.error.message}`);
     }
 
-    // Return 3 hooks configured (SessionStart + UserPromptSubmit + Notification)
+    // Return 1 hook configured (Notification only)
     return {
-      count: 3,
-      message: 'Configured session, message, and notification hooks',
+      count: 1,
+      message: 'Configured notification hook',
     };
   },
 

package/src/targets/functional/claude-code-logic.ts

@@ -31,7 +31,6 @@ export interface ClaudeCodeSettings {
 }
 
 export interface HookConfig {
-  sessionCommand?: string;
   notificationCommand?: string;
 }
 
@@ -41,17 +40,15 @@ export interface HookConfig {
  */
 export const generateHookCommands = async (targetId: string): Promise<HookConfig> => {
   return {
-    sessionCommand: `sylphx-flow hook --type session --target ${targetId}`,
     notificationCommand: `sylphx-flow hook --type notification --target ${targetId}`,
   };
 };
 
 /**
  * Default hook commands (fallback)
- * Simplified to only include session and notification hooks
+ * Simplified to only include notification hook
  */
 export const DEFAULT_HOOKS: HookConfig = {
-  sessionCommand: 'sylphx-flow hook --type session --target claude-code',
   notificationCommand: 'sylphx-flow hook --type notification --target claude-code',
 };
 
@@ -74,20 +71,9 @@ export const parseSettings = (content: string): Result<ClaudeCodeSettings, Confi
 export const buildHookConfiguration = (
   config: HookConfig = DEFAULT_HOOKS
 ): ClaudeCodeSettings['hooks'] => {
-  const sessionCommand = config.sessionCommand || DEFAULT_HOOKS.sessionCommand!;
   const notificationCommand = config.notificationCommand || DEFAULT_HOOKS.notificationCommand!;
 
   return {
-    SessionStart: [
-      {
-        hooks: [
-          {
-            type: 'command',
-            command: sessionCommand,
-          },
-        ],
-      },
-    ],
     Notification: [
       {
         matcher: '',
@@ -140,7 +126,7 @@ export const serializeSettings = (settings: ClaudeCodeSettings): string => {
  * Get success message (pure)
  */
 export const getSuccessMessage = (): string => {
-  return 'Claude Code hooks configured: SessionStart (static info) + UserPromptSubmit (dynamic info)';
+  return 'Claude Code hook configured: Notification';
 };
 
 /**
@@ -173,12 +159,8 @@ export const processSettings = (
  * Validate hook configuration (pure)
  */
 export const validateHookConfig = (config: HookConfig): Result<HookConfig, ConfigError> => {
-  if (config.sessionCommand !== undefined && config.sessionCommand.trim() === '') {
-    return failure(configError('Session command cannot be empty'));
-  }
-
-  if (config.messageCommand !== undefined && config.messageCommand.trim() === '') {
-    return failure(configError('Message command cannot be empty'));
+  if (config.notificationCommand !== undefined && config.notificationCommand.trim() === '') {
+    return failure(configError('Notification command cannot be empty'));
   }
 
   return success(config);

package/src/targets/opencode.ts

@@ -23,12 +23,6 @@ export const opencodeTarget: Target = {
   isImplemented: true,
   isDefault: true,
 
-  mcpServerConfig: {
-    disableTime: false,
-    disableKnowledge: false,
-    disableCodebase: false,
-  },
-
   config: {
     agentDir: '.opencode/agent',
     agentExtension: '.md',