codexspec 0.6.3__tar.gz → 0.6.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codexspec
-Version: 0.6.3
+Version: 0.6.5
 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.5}/pyproject.toml

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

{codexspec-0.6.3 → codexspec-0.6.5}/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
@@ -467,9 +471,11 @@ def init(
         "--force",
         "-f",
         help=(
-            "Overwrite existing files and auto-confirm prompts (skips the language "
-            "prompt and command-update/migration confirms). Language config is updated "
-            "surgically, never fully regenerated."
+            "Overwrite regenerable files (commands/scripts) and auto-confirm prompts "
+            "(skips the language prompt and command-update/migration confirms). "
+            "User-authored content is preserved: language config is updated surgically "
+            "and an existing CLAUDE.md body is never overwritten (only the constitution "
+            "@import is prepended if missing)."
         ),
     ),
     no_git: bool = typer.Option(
@@ -553,21 +559,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:
@@ -749,15 +774,19 @@ def init(
         console.print(f"[dim]{translate('cli.init.language_dimensions_hint', normalized_lang)}[/dim]")
 
     # Create CLAUDE.md
+    # CLAUDE.md is user-authored content (like the constitution), not a
+    # regenerable artifact (like commands/scripts). Never overwrite an existing
+    # body -- even under --force. --force only auto-confirms the one safe,
+    # idempotent change: prepending the constitution @import if it is missing.
     claude_md = target_dir / "CLAUDE.md"
-    if not claude_md.exists() or force:
+    if not claude_md.exists():
         project_name = target_dir.name
         claude_md.write_text(_get_claude_md_content(project_name), encoding="utf-8")
         console.print(f"[green]{translate('cli.init.created_file', normalized_lang, file='CLAUDE.md')}[/green]")
     else:
-        # Check if existing CLAUDE.md has compliance section
+        # Existing CLAUDE.md: ensure the compliance @import, never clobber the body.
         if not has_compliance_section(claude_md):
-            if confirm_add_compliance(normalized_lang):
+            if force or confirm_add_compliance(normalized_lang):
                 prepend_compliance_section(claude_md)
                 console.print(f"[green]{translate('cli.init.compliance_added', normalized_lang)}[/green]")
 
@@ -802,6 +831,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.5}/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.5}/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.5}/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

{codexspec-0.6.3 → codexspec-0.6.5}/templates/commands/implement-tasks.md

@@ -133,10 +133,103 @@ When encountering problems, create/update `issues.md` in the same directory as `
 - **Status**: Blocked / Workaround Found / Needs Discussion
 ```
 
-### 6. Completion
+### 6. Pre-Review Baseline
 
-After all tasks:
+After all tasks are implemented:
 
-- Run full test suite (if applicable)
-- Final commit if needed
-- Report completion summary with files modified
+- Run the full test suite.
+- Confirm the suite is green. This green state is the baseline for the Final
+  Code Review Loop; no auto-fix may regress it. If the suite is already red at
+  this point, stop and fix the implementation before reviewing.
+
+### 7. Final Code Review Loop
+
+After the baseline is green, review the implemented code and auto-fix verified
+defects. This mirrors the `review-spec` / `review-plan` / `review-tasks` loops
+the sibling generation commands run.
+
+#### 7.1 Determine the Review Target
+
+Review only the analyzable code changed by this implementation, not the whole
+repository and not per task. Compute the candidate file set:
+
+```
+git diff --name-only $(git merge-base HEAD <main>)..HEAD
+git diff --name-only                       # uncommitted tracked changes
+git ls-files --others --exclude-standard   # untracked files
+```
+
+`<main>` is the project's default branch, resolved from `git.main_branches` in
+`.codexspec/config.yml` (default: `main`, `master`, `develop`).
+
+Then filter the candidate set:
+
+- Keep only analyzable source extensions: `.py .ts .tsx .js .jsx .go .rs .java
+  .kt .kts .rb .sh .bash .zsh .c .h .cpp .hpp .cc .cxx .cs .swift .php`.
+- Exclude `.codexspec/specs/` and generated/vendored paths (e.g. `dist/`,
+  lockfiles, `.venv/`).
+
+If the filtered set is empty (e.g. the implementation produced only docs,
+config, or assets), report "no code to review", skip this loop, and proceed to
+step 8.
+
+Fallback: if git is unavailable or the current branch is not a feature branch
+(so the diff base cannot be determined), review the project's primary source
+directory as `/codexspec:review-code` would by default, and explicitly note the
+degraded fidelity (the review may include pre-existing code).
+
+#### 7.2 Invoke the Review
+
+Invoke `/codexspec:review-code <filtered-paths>`.
+
+`/codexspec:review-code` is **review-only**; it produces findings and scores but
+does not edit code. Apply every fix **yourself**, under this command's tool
+scope (which includes `Edit`/`Write` and running the test suite via `Bash`).
+
+#### 7.3 Auto-Fix Scope
+
+- Auto-fix **CRITICAL, HIGH, and MEDIUM** findings only.
+- **LOW** (suggestion) findings are report-only; never auto-fix them.
+- A **MEDIUM** finding is auto-fixed only when it is grounded in
+  `.codexspec/memory/constitution.md` and the confirmed requirements/spec, and
+  it concerns **maintainability, readability, or testability**. Ungrounded or
+  purely stylistic MEDIUM findings are report-only.
+- Do not auto-fix advisories or design opportunities, and do not introduce any
+  new product decision.
+
+#### 7.4 Test-Safe Fixes (never ship red)
+
+Every fix must be test-safe. A fix that breaks tests is, by definition, an
+incorrect change — it is never shipped and never silently skipped.
+
+- **Functional defects** (logic, correctness, security): follow TDD — add a
+  failing test that reproduces the defect (red), apply the fix until that test
+  passes (green), then refactor while tests stay green.
+- **Non-functional fixes** (refactors for maintainability, readability,
+  testability): run the suite before and after the change. If the change turns
+  any test red, revert it, confirm the suite is green again, and re-attempt the
+  refactor.
+- If a fix cannot be made green after retry, treat it as **unresolved** and stop
+  (see 7.5).
+
+#### 7.5 Loop Bounds and Stop Conditions
+
+- Run at most **two** fix-and-review rounds. (The per-fix TDD retry in 7.4
+  happens within a round; the two-round limit bounds overall effort.)
+- Stop when a defect repeats, remains unresolved, or requires a user or
+  architecture decision.
+- After each green round, commit the fixes (see step 8).
+
+#### 7.6 Terminal Status
+
+- If CRITICAL or HIGH defects remain unresolved after the maximum rounds, the
+  status is **"needs work"** — do not claim success.
+- Otherwise report the review outcome: scores, items fixed, items deferred, and
+  the final test status.
+
+### 8. Final Report and Commit
+
+- Commit any review-driven changes from step 7 that are not already committed.
+- Report the completion summary: files modified, review status (scores, items
+  fixed, items deferred, final test status), and the overall status (success or
+  "needs work").