specweave 0.16.5 → 0.16.11

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

@@ -1,155 +1,201 @@
-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
-    };
-  }
+/**
+ * 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,
+        };
+    }
 }
+/**
+ * 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) {
-  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
-`);
+    // 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 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
-    );
-  }
 }
-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) {
+/**
+ * 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)})`);
+    }
     return {
-      success: true,
-      filePath,
-      sourceLanguage: sourceLang,
-      targetLanguage: targetLang,
-      originalContent: content,
-      translatedContent: content
+        ...result,
+        filePath,
     };
-  }
-  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
-  };
 }
-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
-      });
+/**
+ * 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,
+            });
+        }
     }
-  }
-  const successful = results.filter((r) => r.success).length;
-  console.log(`
-\u{1F4CA} Batch translation complete: ${successful}/${filePaths.length} files translated
-`);
-  return results;
+    // Summary
+    const successful = results.filter(r => r.success).length;
+    console.log(`\n📊 Batch translation complete: ${successful}/${filePaths.length} files translated\n`);
+    return results;
 }
-export {
-  batchTranslateFiles,
-  invokeTranslatorSkill,
-  translateFile
-};
+//# sourceMappingURL=invoke-translator-skill.js.map

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

@@ -1,110 +1,123 @@
-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;
+/**
+ * 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;
+    }
+    catch (error) {
+        console.error(`Failed to prepare reflection context: ${error.message}`);
+        return null;
     }
-    const rootDir = projectRoot || process.cwd();
-    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;
-  }
 }
-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);
+/**
+ * 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);
 }
-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;
-  }
+/**
+ * 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 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);
-  }
+/**
+ * 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);
+    }
 }
+// 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("\u2728 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('✨ Reflection ready. Run /specweave:reflect to analyze your work.');
+    }
+    else {
+        console.log('Reflection skipped (disabled or no changes).');
+    }
 }
-export {
-  clearReflectionContext,
-  hasReflectionContext,
-  prepareReflectionContext,
-  readReflectionContext
-};
+//# sourceMappingURL=prepare-reflection-context.js.map