specweave 0.13.5 → 0.14.0

package/plugins/specweave/lib/hooks/invoke-translator-skill.js

@@ -1,201 +1,155 @@
-/**
- * Translator Skill Invocation Utility
- *
- * Provides programmatic invocation of the translator skill for automated translation.
- * Used by hooks and CLI scripts to translate content without manual intervention.
- *
- * @see plugins/specweave/skills/translator/SKILL.md
- * @see plugins/specweave/commands/translate.md
- */
-import fs from 'fs-extra';
-import { detectLanguage, prepareTranslation, postProcessTranslation, getLanguageName, } from '../../../../src/utils/translation.js';
-/**
- * Invokes translator skill to translate content
- *
- * This function integrates with the translator skill by:
- * 1. Preparing translation prompt
- * 2. Writing prompt to a temp file
- * 3. Outputting instructions for Claude to process
- * 4. Returning the translated content
- *
- * In an automated context (hooks), this provides clear instructions.
- * In an interactive context, the translator skill can auto-activate.
- *
- * @param content - Content to translate
- * @param sourceLang - Source language
- * @param targetLang - Target language
- * @returns Translation result
- */
-export async function invokeTranslatorSkill(content, sourceLang, targetLang = 'en') {
-    try {
-        // Prepare translation
-        const prepared = prepareTranslation(content, sourceLang, targetLang);
-        // For now, we use a practical approach:
-        // Output the translation request clearly so it can be processed
-        const result = {
-            success: true,
-            sourceLanguage: sourceLang,
-            targetLanguage: targetLang,
-            originalContent: content,
-            translatedContent: await performTranslation(prepared.prompt, prepared.preserved),
-        };
-        return result;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            success: false,
-            sourceLanguage: sourceLang,
-            targetLanguage: targetLang,
-            originalContent: content,
-            error: errorMessage,
-        };
-    }
+import fs from "fs-extra";
+import {
+  detectLanguage,
+  prepareTranslation,
+  postProcessTranslation,
+  getLanguageName
+} from "../../../../src/utils/translation.js";
+async function invokeTranslatorSkill(content, sourceLang, targetLang = "en") {
+  try {
+    const prepared = prepareTranslation(content, sourceLang, targetLang);
+    const result = {
+      success: true,
+      sourceLanguage: sourceLang,
+      targetLanguage: targetLang,
+      originalContent: content,
+      translatedContent: await performTranslation(prepared.prompt, prepared.preserved)
+    };
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      sourceLanguage: sourceLang,
+      targetLanguage: targetLang,
+      originalContent: content,
+      error: errorMessage
+    };
+  }
 }
-/**
- * Performs the actual translation using Anthropic API
- *
- * PRODUCTION IMPLEMENTATION:
- * 1. Checks for ANTHROPIC_API_KEY in environment
- * 2. If available: Uses Anthropic API directly (fully automatic)
- * 3. If not available: Provides clear instructions for manual translation
- *
- * @param prompt - Translation prompt
- * @param preserved - Preserved content structure
- * @returns Translated content
- */
 async function performTranslation(prompt, preserved) {
-    // Extract content for processing
-    const contentMatch = prompt.match(/SOURCE DOCUMENT[^\n]*:\n---\n([\s\S]*?)\n---/);
-    const contentToTranslate = contentMatch ? contentMatch[1] : '';
-    // Check if ANTHROPIC_API_KEY is available
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (apiKey) {
-        // Fully automatic translation using Anthropic API
-        console.log(`\n🤖 Translating via Anthropic API (Haiku model)...`);
-        try {
-            // Dynamic import of Anthropic SDK (allows graceful fallback if not installed)
-            const Anthropic = await import('@anthropic-ai/sdk').then(m => m.default);
-            const anthropic = new Anthropic({
-                apiKey,
-            });
-            const message = await anthropic.messages.create({
-                model: 'claude-3-haiku-20240307',
-                max_tokens: 8000,
-                messages: [
-                    {
-                        role: 'user',
-                        content: prompt,
-                    },
-                ],
-            });
-            // Extract translated content from response
-            const translatedContent = message.content[0].type === 'text'
-                ? message.content[0].text
-                : contentToTranslate;
-            console.log(`✅ Translation complete via API`);
-            console.log(`   Input tokens: ${message.usage.input_tokens}`);
-            console.log(`   Output tokens: ${message.usage.output_tokens}`);
-            console.log(`   Cost: ~$${((message.usage.input_tokens * 0.25 + message.usage.output_tokens * 1.25) / 1000000).toFixed(4)}\n`);
-            return postProcessTranslation(translatedContent, preserved);
-        }
-        catch (error) {
-            console.error(`\n❌ API translation failed: ${error.message}`);
-            console.error(`   Falling back to manual translation instructions\n`);
-            // Fall through to manual instructions
-        }
-    }
-    // Fallback: Manual translation instructions
-    const isInteractive = process.env.CLAUDE_CODE_SESSION === 'true';
-    if (isInteractive) {
-        // In Claude Code environment, output translation request
-        console.log('\n' + '='.repeat(80));
-        console.log('🌐 TRANSLATION REQUEST (translator skill will auto-activate)');
-        console.log('='.repeat(80));
-        console.log(prompt);
-        console.log('='.repeat(80));
-        console.log('💡 Tip: Set ANTHROPIC_API_KEY for fully automatic translation\n');
-        return postProcessTranslation(`<!-- ⚠️ TRANSLATION REQUESTED - Awaiting translator skill activation -->\n\n${contentToTranslate}`, preserved);
-    }
-    else {
-        // Non-interactive environment - provide clear instructions
-        console.error('\n⚠️  AUTO-TRANSLATION REQUIRES ONE OF:');
-        console.error('   Option A (Recommended): Set ANTHROPIC_API_KEY environment variable');
-        console.error('   Option B: Run /specweave:translate <file-path>');
-        console.error('   Option C: Manually translate the content\n');
-        return postProcessTranslation(`<!-- ⚠️ AUTO-TRANSLATION PENDING -->\n<!-- Set ANTHROPIC_API_KEY for automatic translation -->\n<!-- Or run: /specweave:translate to complete -->\n<!-- Original content below -->\n\n${contentToTranslate}`, preserved);
+  const contentMatch = prompt.match(/SOURCE DOCUMENT[^\n]*:\n---\n([\s\S]*?)\n---/);
+  const contentToTranslate = contentMatch ? contentMatch[1] : "";
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (apiKey) {
+    console.log(`
+\u{1F916} Translating via Anthropic API (Haiku model)...`);
+    try {
+      const Anthropic = await import("@anthropic-ai/sdk").then((m) => m.default);
+      const anthropic = new Anthropic({
+        apiKey
+      });
+      const message = await anthropic.messages.create({
+        model: "claude-3-haiku-20240307",
+        max_tokens: 8e3,
+        messages: [
+          {
+            role: "user",
+            content: prompt
+          }
+        ]
+      });
+      const translatedContent = message.content[0].type === "text" ? message.content[0].text : contentToTranslate;
+      console.log(`\u2705 Translation complete via API`);
+      console.log(`   Input tokens: ${message.usage.input_tokens}`);
+      console.log(`   Output tokens: ${message.usage.output_tokens}`);
+      console.log(`   Cost: ~$${((message.usage.input_tokens * 0.25 + message.usage.output_tokens * 1.25) / 1e6).toFixed(4)}
+`);
+      return postProcessTranslation(translatedContent, preserved);
+    } catch (error) {
+      console.error(`
+\u274C API translation failed: ${error.message}`);
+      console.error(`   Falling back to manual translation instructions
+`);
     }
+  }
+  const isInteractive = process.env.CLAUDE_CODE_SESSION === "true";
+  if (isInteractive) {
+    console.log("\n" + "=".repeat(80));
+    console.log("\u{1F310} TRANSLATION REQUEST (translator skill will auto-activate)");
+    console.log("=".repeat(80));
+    console.log(prompt);
+    console.log("=".repeat(80));
+    console.log("\u{1F4A1} Tip: Set ANTHROPIC_API_KEY for fully automatic translation\n");
+    return postProcessTranslation(
+      `<!-- \u26A0\uFE0F TRANSLATION REQUESTED - Awaiting translator skill activation -->
+
+${contentToTranslate}`,
+      preserved
+    );
+  } else {
+    console.error("\n\u26A0\uFE0F  AUTO-TRANSLATION REQUIRES ONE OF:");
+    console.error("   Option A (Recommended): Set ANTHROPIC_API_KEY environment variable");
+    console.error("   Option B: Run /specweave:translate <file-path>");
+    console.error("   Option C: Manually translate the content\n");
+    return postProcessTranslation(
+      `<!-- \u26A0\uFE0F AUTO-TRANSLATION PENDING -->
+<!-- Set ANTHROPIC_API_KEY for automatic translation -->
+<!-- Or run: /specweave:translate to complete -->
+<!-- Original content below -->
+
+${contentToTranslate}`,
+      preserved
+    );
+  }
 }
-/**
- * Translate a file using translator skill
- *
- * @param filePath - Path to file to translate
- * @param targetLang - Target language
- * @returns Translation result
- */
-export async function translateFile(filePath, targetLang = 'en') {
-    // Read file
-    if (!await fs.pathExists(filePath)) {
-        throw new Error(`File not found: ${filePath}`);
-    }
-    const content = await fs.readFile(filePath, 'utf-8');
-    // Detect source language
-    const detection = detectLanguage(content);
-    const sourceLang = detection.language;
-    // Check if already in target language
-    if (sourceLang === targetLang) {
-        return {
-            success: true,
-            filePath,
-            sourceLanguage: sourceLang,
-            targetLanguage: targetLang,
-            originalContent: content,
-            translatedContent: content,
-        };
-    }
-    // Translate
-    const result = await invokeTranslatorSkill(content, sourceLang, targetLang);
-    // Write back if successful
-    if (result.success && result.translatedContent) {
-        await fs.writeFile(filePath, result.translatedContent, 'utf-8');
-        console.log(`✅ Translated: ${filePath} (${getLanguageName(sourceLang)} → ${getLanguageName(targetLang)})`);
-    }
+async function translateFile(filePath, targetLang = "en") {
+  if (!await fs.pathExists(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const content = await fs.readFile(filePath, "utf-8");
+  const detection = detectLanguage(content);
+  const sourceLang = detection.language;
+  if (sourceLang === targetLang) {
     return {
-        ...result,
-        filePath,
+      success: true,
+      filePath,
+      sourceLanguage: sourceLang,
+      targetLanguage: targetLang,
+      originalContent: content,
+      translatedContent: content
     };
+  }
+  const result = await invokeTranslatorSkill(content, sourceLang, targetLang);
+  if (result.success && result.translatedContent) {
+    await fs.writeFile(filePath, result.translatedContent, "utf-8");
+    console.log(`\u2705 Translated: ${filePath} (${getLanguageName(sourceLang)} \u2192 ${getLanguageName(targetLang)})`);
+  }
+  return {
+    ...result,
+    filePath
+  };
 }
-/**
- * Batch translate multiple files
- *
- * @param filePaths - Array of file paths
- * @param targetLang - Target language
- * @returns Array of translation results
- */
-export async function batchTranslateFiles(filePaths, targetLang = 'en') {
-    const results = [];
-    console.log(`\n🌐 Batch translating ${filePaths.length} file(s) to ${getLanguageName(targetLang)}...\n`);
-    for (const filePath of filePaths) {
-        try {
-            const result = await translateFile(filePath, targetLang);
-            results.push(result);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error(`❌ Failed to translate ${filePath}: ${errorMessage}`);
-            results.push({
-                success: false,
-                filePath,
-                sourceLanguage: 'unknown',
-                targetLanguage: targetLang,
-                originalContent: '',
-                error: errorMessage,
-            });
-        }
+async function batchTranslateFiles(filePaths, targetLang = "en") {
+  const results = [];
+  console.log(`
+\u{1F310} Batch translating ${filePaths.length} file(s) to ${getLanguageName(targetLang)}...
+`);
+  for (const filePath of filePaths) {
+    try {
+      const result = await translateFile(filePath, targetLang);
+      results.push(result);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`\u274C Failed to translate ${filePath}: ${errorMessage}`);
+      results.push({
+        success: false,
+        filePath,
+        sourceLanguage: "unknown",
+        targetLanguage: targetLang,
+        originalContent: "",
+        error: errorMessage
+      });
     }
-    // Summary
-    const successful = results.filter(r => r.success).length;
-    console.log(`\n📊 Batch translation complete: ${successful}/${filePaths.length} files translated\n`);
-    return results;
+  }
+  const successful = results.filter((r) => r.success).length;
+  console.log(`
+\u{1F4CA} Batch translation complete: ${successful}/${filePaths.length} files translated
+`);
+  return results;
 }
-//# sourceMappingURL=invoke-translator-skill.js.map
+export {
+  batchTranslateFiles,
+  invokeTranslatorSkill,
+  translateFile
+};

package/plugins/specweave/lib/hooks/prepare-reflection-context.js

@@ -1,123 +1,110 @@
-/**
- * Prepare Reflection Context
- *
- * Prepares context for reflection and saves to temp file
- * Used by post-task-completion hook to prepare for reflection invocation
- *
- * @module prepare-reflection-context
- */
-import fs from 'fs-extra';
-import path from 'path';
-import { createReflectionContext } from './run-self-reflection';
-import { getModifiedFilesSummary } from './git-diff-analyzer';
-/**
- * Prepare reflection context and save to temp file
- * This allows the hook to prepare data without actually invoking the agent
- *
- * @param incrementId Increment identifier
- * @param taskId Task identifier
- * @param projectRoot Project root directory (optional)
- * @returns Path to saved context file or null if reflection should be skipped
- */
-export function prepareReflectionContext(incrementId, taskId, projectRoot) {
-    try {
-        const context = createReflectionContext(incrementId, taskId, projectRoot);
-        // Check if reflection should run
-        if (!context.config.enabled || context.modifiedFiles.length === 0) {
-            return null;
-        }
-        // Create temp directory for reflection context
-        const rootDir = projectRoot || process.cwd();
-        const tempDir = path.join(rootDir, '.specweave', 'increments', incrementId, 'logs', 'reflections', '.temp');
-        fs.mkdirpSync(tempDir);
-        // Save context to temp file
-        const contextFile = path.join(tempDir, 'reflection-context.json');
-        const fileStats = getModifiedFilesSummary(context.modifiedFiles);
-        const contextData = {
-            incrementId: context.incrementId,
-            taskId: context.taskId,
-            modifiedFiles: context.modifiedFiles.map(f => ({
-                file: f.file,
-                linesAdded: f.linesAdded,
-                linesRemoved: f.linesRemoved
-                // Exclude diff content to save space
-            })),
-            fileSummary: {
-                count: fileStats.count,
-                linesAdded: fileStats.linesAdded,
-                linesRemoved: fileStats.linesRemoved
-            },
-            config: context.config,
-            timestamp: new Date().toISOString()
-        };
-        fs.writeJsonSync(contextFile, contextData, { spaces: 2 });
-        return contextFile;
+import fs from "fs-extra";
+import path from "path";
+import { createReflectionContext } from "./run-self-reflection";
+import { getModifiedFilesSummary } from "./git-diff-analyzer";
+function prepareReflectionContext(incrementId, taskId, projectRoot) {
+  try {
+    const context = createReflectionContext(incrementId, taskId, projectRoot);
+    if (!context.config.enabled || context.modifiedFiles.length === 0) {
+      return null;
     }
-    catch (error) {
-        console.error(`Failed to prepare reflection context: ${error.message}`);
-        return null;
-    }
-}
-/**
- * Check if reflection context exists for an increment
- *
- * @param incrementId Increment identifier
- * @param projectRoot Project root directory (optional)
- * @returns True if context file exists
- */
-export function hasReflectionContext(incrementId, projectRoot) {
     const rootDir = projectRoot || process.cwd();
-    const contextFile = path.join(rootDir, '.specweave', 'increments', incrementId, 'logs', 'reflections', '.temp', 'reflection-context.json');
-    return fs.existsSync(contextFile);
+    const tempDir = path.join(rootDir, ".specweave", "increments", incrementId, "logs", "reflections", ".temp");
+    fs.mkdirpSync(tempDir);
+    const contextFile = path.join(tempDir, "reflection-context.json");
+    const fileStats = getModifiedFilesSummary(context.modifiedFiles);
+    const contextData = {
+      incrementId: context.incrementId,
+      taskId: context.taskId,
+      modifiedFiles: context.modifiedFiles.map((f) => ({
+        file: f.file,
+        linesAdded: f.linesAdded,
+        linesRemoved: f.linesRemoved
+        // Exclude diff content to save space
+      })),
+      fileSummary: {
+        count: fileStats.count,
+        linesAdded: fileStats.linesAdded,
+        linesRemoved: fileStats.linesRemoved
+      },
+      config: context.config,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs.writeJsonSync(contextFile, contextData, { spaces: 2 });
+    return contextFile;
+  } catch (error) {
+    console.error(`Failed to prepare reflection context: ${error.message}`);
+    return null;
+  }
 }
-/**
- * Read reflection context from file
- *
- * @param incrementId Increment identifier
- * @param projectRoot Project root directory (optional)
- * @returns Context data or null if not found
- */
-export function readReflectionContext(incrementId, projectRoot) {
-    const rootDir = projectRoot || process.cwd();
-    const contextFile = path.join(rootDir, '.specweave', 'increments', incrementId, 'logs', 'reflections', '.temp', 'reflection-context.json');
-    if (!fs.existsSync(contextFile)) {
-        return null;
-    }
-    try {
-        return fs.readJsonSync(contextFile);
-    }
-    catch {
-        return null;
-    }
+function hasReflectionContext(incrementId, projectRoot) {
+  const rootDir = projectRoot || process.cwd();
+  const contextFile = path.join(
+    rootDir,
+    ".specweave",
+    "increments",
+    incrementId,
+    "logs",
+    "reflections",
+    ".temp",
+    "reflection-context.json"
+  );
+  return fs.existsSync(contextFile);
 }
-/**
- * Clear reflection context after reflection completes
- *
- * @param incrementId Increment identifier
- * @param projectRoot Project root directory (optional)
- */
-export function clearReflectionContext(incrementId, projectRoot) {
-    const rootDir = projectRoot || process.cwd();
-    const tempDir = path.join(rootDir, '.specweave', 'increments', incrementId, 'logs', 'reflections', '.temp');
-    if (fs.existsSync(tempDir)) {
-        fs.removeSync(tempDir);
-    }
+function readReflectionContext(incrementId, projectRoot) {
+  const rootDir = projectRoot || process.cwd();
+  const contextFile = path.join(
+    rootDir,
+    ".specweave",
+    "increments",
+    incrementId,
+    "logs",
+    "reflections",
+    ".temp",
+    "reflection-context.json"
+  );
+  if (!fs.existsSync(contextFile)) {
+    return null;
+  }
+  try {
+    return fs.readJsonSync(contextFile);
+  } catch {
+    return null;
+  }
+}
+function clearReflectionContext(incrementId, projectRoot) {
+  const rootDir = projectRoot || process.cwd();
+  const tempDir = path.join(
+    rootDir,
+    ".specweave",
+    "increments",
+    incrementId,
+    "logs",
+    "reflections",
+    ".temp"
+  );
+  if (fs.existsSync(tempDir)) {
+    fs.removeSync(tempDir);
+  }
 }
-// CLI entry point for hook integration
 if (require.main === module) {
-    const incrementId = process.argv[2];
-    const taskId = process.argv[3];
-    if (!incrementId || !taskId) {
-        console.error('Usage: node prepare-reflection-context.js <increment-id> <task-id>');
-        process.exit(1);
-    }
-    const contextFile = prepareReflectionContext(incrementId, taskId);
-    if (contextFile) {
-        console.log(`Reflection context prepared: ${contextFile}`);
-        console.log('✨ Reflection ready. Run /specweave:reflect to analyze your work.');
-    }
-    else {
-        console.log('Reflection skipped (disabled or no changes).');
-    }
+  const incrementId = process.argv[2];
+  const taskId = process.argv[3];
+  if (!incrementId || !taskId) {
+    console.error("Usage: node prepare-reflection-context.js <increment-id> <task-id>");
+    process.exit(1);
+  }
+  const contextFile = prepareReflectionContext(incrementId, taskId);
+  if (contextFile) {
+    console.log(`Reflection context prepared: ${contextFile}`);
+    console.log("\u2728 Reflection ready. Run /specweave:reflect to analyze your work.");
+  } else {
+    console.log("Reflection skipped (disabled or no changes).");
+  }
 }
-//# sourceMappingURL=prepare-reflection-context.js.map
+export {
+  clearReflectionContext,
+  hasReflectionContext,
+  prepareReflectionContext,
+  readReflectionContext
+};