codexspec 0.6.3__tar.gz → 0.6.4__tar.gz

{codexspec-0.6.3 → codexspec-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codexspec
-Version: 0.6.3
+Version: 0.6.4
 Summary: CodexSpec - A Requirements-First SDD toolkit for Claude Code
 Project-URL: Homepage, https://github.com/Zts0hg/codexspec
 Project-URL: Repository, https://github.com/Zts0hg/codexspec

{codexspec-0.6.3 → codexspec-0.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codexspec"
-version = "0.6.3"
+version = "0.6.4"
 description = "CodexSpec - A Requirements-First SDD toolkit for Claude Code"
 readme = "README.md"
 requires-python = ">=3.11"

{codexspec-0.6.3 → codexspec-0.6.4}/src/codexspec/__init__.py

@@ -26,9 +26,11 @@ from .commands.installer import (
     install_commands_to_subdir,
     migrate_old_commands,
     should_update_commands,
+    update_installed_command_frontmatter,
 )
 from .i18n import (
     generate_config_content,
+    get_explicit_language_key,
     get_interaction_language,
     get_language_name,
     get_supported_languages,
@@ -36,7 +38,7 @@ from .i18n import (
     normalize_locale,
     update_language_field,
 )
-from .translator import translate
+from .translator import SUPPORTED_LANGUAGES, translate
 
 # Version info
 __version__ = "0.6.0"
@@ -270,6 +272,7 @@ def config(
         else:
             console.print("[red]Failed to update language setting[/red]")
             raise typer.Exit(1)
+        _rerender_command_frontmatter(config_file)
         return
 
     # Handle set commit language
@@ -348,6 +351,7 @@ def config(
         else:
             console.print("[red]Failed to update interaction language setting[/red]")
             raise typer.Exit(1)
+        _rerender_command_frontmatter(config_file)
         return
 
     # Handle set document language
@@ -553,21 +557,40 @@ def init(
     )
     prompted_base = False
     if base_determinable:
-        normalized_lang = normalize_locale(output_value) if output_value else "en"
+        # Output base already resolved (or None when only dimension flags were
+        # given); no prompt needed to resolve it.
+        pass
     elif config_exists:
-        normalized_lang = get_interaction_language(config_file)
+        # Existing project: preserve every unspecified key (REQ-007); no prompt.
+        pass
     elif sys.stdin.isatty():
         try:
             output_value = normalize_locale(prompt_language_selection())
             prompted_base = True
-            normalized_lang = output_value
         except KeyboardInterrupt:
             console.print()
             console.print("[yellow]Selection cancelled, using default language (en)[/yellow]")
             output_value = "en"
-            normalized_lang = "en"
     else:
         output_value = "en"
+
+    # Render/CLI-message language = the effective interaction language for THIS
+    # run (frontmatter descriptions are an interaction-language artifact). This is
+    # deliberately decoupled from output_value/prompted_base above, which only
+    # drive config writing and the first-time prompt. Precedence: explicit
+    # --interaction-lang -> explicitly-configured interaction -> --lang (output
+    # base) -> explicitly-configured output -> "en". Existing interaction is
+    # deliberately stronger than --lang; existing output is only a fallback when
+    # this run did not provide a new base.
+    if "interaction" in lang_overrides:
+        normalized_lang = lang_overrides["interaction"]
+    elif config_exists and (explicit_interaction := get_explicit_language_key(config_file, "interaction")) is not None:
+        normalized_lang = explicit_interaction
+    elif output_value is not None:
+        normalized_lang = output_value
+    elif config_exists and (explicit_output := get_explicit_language_key(config_file, "output")) is not None:
+        normalized_lang = explicit_output
+    else:
         normalized_lang = "en"
 
     if debug:
@@ -802,6 +825,29 @@ def init(
     console.print(f"[yellow]{translate('cli.init.important_action', normalized_lang)}[/yellow]")
 
 
+def _rerender_command_frontmatter(config_file: Path) -> None:
+    """Re-render installed command frontmatter in the current interaction language.
+
+    Called after a ``config`` language change so ``.claude/commands/codexspec/*.md``
+    descriptions follow the new interaction language immediately, mirroring what
+    ``init`` does. No-op when commands are not installed. Languages without a
+    pre-translated cache are not re-rendered here (that path would invoke the
+    ``claude`` CLI once per command); the user is advised to run ``codexspec init``.
+    """
+    commands_subdir = Path.cwd() / ".claude" / "commands" / COMMANDS_SUBDIR
+    if not commands_subdir.exists():
+        return
+    language = get_interaction_language(config_file)  # re-read AFTER the config write
+    if language != "en" and language not in SUPPORTED_LANGUAGES:
+        console.print(f"[dim]Run [cyan]codexspec init[/cyan] to update command descriptions for {language}.[/dim]")
+        return
+    templates_dir = get_templates_dir() / "commands"
+    if not templates_dir.exists():
+        return
+    update_installed_command_frontmatter(commands_subdir, templates_dir, language=language)
+    console.print(f"[dim]Updated command descriptions to: {get_language_name(language)}[/dim]")
+
+
 def _print_command_summary(language: str = "en") -> None:
     """Print a summary of installed commands grouped by category."""
     metadata = get_commands_metadata()

{codexspec-0.6.3 → codexspec-0.6.4}/src/codexspec/commands/installer.py

@@ -8,7 +8,12 @@ import shutil
 from pathlib import Path
 from typing import Optional, TypedDict
 
-from codexspec.translator import extract_frontmatter_fields, load_translation_cache, translate_template_frontmatter
+from codexspec.translator import (
+    apply_translations_to_template,
+    extract_frontmatter_fields,
+    load_translation_cache,
+    translate_template_frontmatter,
+)
 
 # Constants
 COMMANDS_SUBDIR = "codexspec"  # Subdirectory name for commands
@@ -348,6 +353,49 @@ def install_commands_to_subdir(
     return installed_count
 
 
+def update_installed_command_frontmatter(
+    target_dir: Path,
+    templates_dir: Path,
+    language: str = "en",
+    translations_dir: Optional[Path] = None,
+) -> int:
+    """Update frontmatter translations for already-installed command files.
+
+    This preserves command bodies and any non-translated frontmatter while
+    refreshing the language-specific ``description`` and ``argument-hint`` fields.
+    Missing installed commands are intentionally skipped.
+    """
+    if not target_dir.exists() or not templates_dir.exists():
+        return 0
+
+    translation_cache = None
+    if language != "en":
+        translation_cache = load_translation_cache(language, translations_dir)
+
+    updated_count = 0
+    for template_file in templates_dir.glob("*.md"):
+        target_path = target_dir / template_file.name
+        if not target_path.exists():
+            continue
+
+        template_content = template_file.read_text(encoding="utf-8")
+        template_name = template_file.stem
+        rendered_template = translate_template_frontmatter(template_content, template_name, language, translation_cache)
+        fields = {
+            key: value for key, value in extract_frontmatter_fields(rendered_template).items() if value is not None
+        }
+        if not fields:
+            continue
+
+        current_content = target_path.read_text(encoding="utf-8")
+        updated_content = apply_translations_to_template(current_content, fields)
+        if updated_content != current_content:
+            target_path.write_text(updated_content, encoding="utf-8")
+            updated_count += 1
+
+    return updated_count
+
+
 def should_update_commands(codexspec_dir: Path) -> bool:
     """Check if commands need updating (subdirectory already exists).
 

{codexspec-0.6.3 → codexspec-0.6.4}/src/codexspec/i18n.py

@@ -290,6 +290,24 @@ def _resolve_language(config_file: Path, primary_key: str) -> str:
     return "en"
 
 
+def get_explicit_language_key(config_file: Optional[Path], key: str) -> Optional[str]:
+    """Return one explicitly configured ``language.<key>`` value, if present.
+
+    This differs from the public language-resolution helpers because it never
+    falls back to ``language.output`` or ``"en"``.
+    """
+    path = config_file or _default_config_path()
+    if not path.exists():
+        return None
+    try:
+        value = _read_language_key(path.read_text(encoding="utf-8"), key)
+        if value:
+            return normalize_locale(value) or None
+    except (OSError, re.error):
+        pass
+    return None
+
+
 def _default_config_path() -> Path:
     return Path.cwd() / ".codexspec" / "config.yml"
 

{codexspec-0.6.3 → codexspec-0.6.4}/src/codexspec/translator.py

@@ -7,8 +7,6 @@ frontmatter fields (description, argument-hint).
 import json
 import logging
 import re
-import shutil
-import subprocess
 from pathlib import Path
 from typing import Optional
 
@@ -336,87 +334,56 @@ def apply_translations_to_template(content: str, translations: dict) -> str:
     Returns:
         Template content with translated frontmatter
     """
+    frontmatter_match = re.match(r"^(---\n)(.*?)(\n---(?:\n|$))", content, re.DOTALL)
+    if not frontmatter_match:
+        return content
+
+    prefix, frontmatter, suffix = frontmatter_match.groups()
+
     # Replace description
     if "description" in translations:
-        content = re.sub(r"^(description:\s*).+$", rf"\g<1>{translations['description']}", content, flags=re.MULTILINE)
+        frontmatter = re.sub(
+            r"^(description:\s*).+$",
+            lambda match: f"{match.group(1)}{translations['description']}",
+            frontmatter,
+            flags=re.MULTILINE,
+        )
 
     # Replace argument-hint (handle both single-line and multiline)
     if "argument-hint" in translations:
         new_hint = translations["argument-hint"]
         # Check if original hint is multiline (uses |)
-        if re.search(r"^argument-hint:\s*\|", content, re.MULTILINE):
+        if re.search(r"^argument-hint:\s*\|", frontmatter, re.MULTILINE):
             # Build new multiline content with proper indentation
             # Only add indentation to non-empty lines
             hint_lines = new_hint.split("\n")
             indented_lines = [("  " + line) if line else "" for line in hint_lines]
             indented_hint = "\n".join(indented_lines)
             # Replace multiline hint - match the entire multiline block (supports empty lines)
-            content = re.sub(
+            frontmatter = re.sub(
                 r"(argument-hint:\s*\|)\s*\n((?:  .+\n?|\s*\n)+)",
-                rf"\g<1>\n{indented_hint}\n",
-                content,
+                lambda match: f"{match.group(1)}\n{indented_hint}\n",
+                frontmatter,
                 flags=re.MULTILINE,
             )
         else:
             # Replace single-line hint (with or without quotes)
-            if re.search(r'^argument-hint:\s*"', content, re.MULTILINE):
-                content = re.sub(r'^(argument-hint:\s*)"[^"]+"$', rf'\g<1>"{new_hint}"', content, flags=re.MULTILINE)
+            if re.search(r'^argument-hint:\s*"', frontmatter, re.MULTILINE):
+                frontmatter = re.sub(
+                    r'^(argument-hint:\s*)"[^"]+"$',
+                    lambda match: f'{match.group(1)}"{new_hint}"',
+                    frontmatter,
+                    flags=re.MULTILINE,
+                )
             else:
-                content = re.sub(r"^(argument-hint:\s*).+$", rf"\g<1>{new_hint}", content, flags=re.MULTILINE)
-
-    return content
-
-
-def check_claude_cli_available() -> bool:
-    """Check if Claude CLI is available.
-
-    Returns:
-        True if claude command is available
-    """
-    return shutil.which("claude") is not None
+                frontmatter = re.sub(
+                    r"^(argument-hint:\s*).+$",
+                    lambda match: f"{match.group(1)}{new_hint}",
+                    frontmatter,
+                    flags=re.MULTILINE,
+                )
 
-
-def translate_with_claude_cli(
-    texts: dict[str, dict[str, str]], target_lang: str, timeout: int = 60
-) -> Optional[dict[str, dict[str, str]]]:
-    """Translate texts using Claude CLI.
-
-    Args:
-        texts: Dictionary of {command_name: {field: text}}
-        target_lang: Target language code
-        timeout: Timeout in seconds
-
-    Returns:
-        Translated dictionary or None on failure
-    """
-    if not check_claude_cli_available():
-        return None
-
-    # Build prompt
-    input_json = json.dumps(texts, ensure_ascii=False, indent=2)
-    prompt = f"""Translate the following JSON values to {target_lang}.
-Keep all keys unchanged. Return only valid JSON with the same structure.
-Do not translate technical terms like "spec.md", "plan.md", "TDD", etc.
-
-{input_json}"""
-
-    try:
-        result = subprocess.run(["claude", "--print", prompt], capture_output=True, text=True, timeout=timeout)
-
-        if result.returncode != 0:
-            return None
-
-        # Parse JSON from output
-        output = result.stdout.strip()
-        # Remove potential markdown code blocks
-        if output.startswith("```"):
-            output = re.sub(r"^```(?:json)?\n?", "", output)
-            output = re.sub(r"\n?```$", "", output)
-
-        return json.loads(output)
-
-    except (subprocess.TimeoutExpired, json.JSONDecodeError, OSError):
-        return None
+    return f"{prefix}{frontmatter}{suffix}{content[frontmatter_match.end() :]}"
 
 
 def translate_template_frontmatter(
@@ -445,13 +412,8 @@ def translate_template_frontmatter(
     if cache and template_name in cache:
         return apply_translations_to_template(template_content, cache[template_name])
 
-    # For non-cached languages, try dynamic translation
-    if target_lang not in SUPPORTED_LANGUAGES:
-        fields = extract_frontmatter_fields(template_content)
-        if fields.get("description") or fields.get("argument-hint"):
-            translations = translate_with_claude_cli({template_name: fields}, target_lang)
-            if translations and template_name in translations:
-                return apply_translations_to_template(template_content, translations[template_name])
-
-    # Return original if all translation attempts fail
+    # No cache for this language: keep the original (English) frontmatter.
+    # Command templates are translated at runtime by Claude reading config.yml
+    # (see the template "Language Preference" section), never via a subprocess
+    # at install time.
     return template_content