ai-codeindex 0.26.0__tar.gz → 0.26.1__tar.gz

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/.gitignore

@@ -36,3 +36,4 @@ htmlcov/
 
 # Validation reports (generated)
 scripts/validation/reports/*.md
+*.code-workspace

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.26.1] - 2026-06-05
+
+**Theme**: GitFlow + non-Python UX patch. Four bug fixes from continued fabricOS dogfood — all paths where `codeindex` silently no-op'd or warned about state that wasn't real. No contract changes.
+
+### Fixed
+
+- **`codeindex hooks install post-commit` now warns when `.codeindex.yaml` disables the hook** (GH #87): `codeindex init` ships the yaml with `hooks.post_commit.enabled: false` by default, so the installed `.git/hooks/post-commit` wrapper would check the flag at runtime and silently no-op. The install command printed ✓, the user committed code, and `README_AI.md` never updated — classic "installed but not working" trap. New `_maybe_warn_post_commit_disabled` helper reads the yaml after install; when `post_commit.enabled` is false (or absent), prints an actionable reminder with the exact yaml snippet to flip. No behavior change to the install itself — patch-safe. (The doubly-opt-in default itself is a separate contract question deliberately deferred from this patch; the reminder is enough to unblock the first-time path.)
+- **`codeindex init` no longer false-flags installed TS/JS parsers as missing + install hint matches the documented pipx path** (GH #86): `init_wizard.PARSER_PACKAGES` enumerated only python/php/java even though scanner gained TS/JS parsers (#73) and the parser modules exist under `src/codeindex/parsers/{typescript,javascript}/`. Result on a TS-only project: `init --yes` printed `Warning: Missing parsers for: javascript, typescript` despite `pipx inject ai-codeindex tree-sitter-{typescript,javascript}` confirming the packages were already installed. Worse, the hint said `Install with: pip install ai-codeindex[...]` — contradicts the entire documented install path (`pipx install ai-codeindex` everywhere else in CLAUDE.md, README, hooks/index SKILL) and doesn't even work cleanly for a pipx-managed env. Fix: extend `PARSER_PACKAGES` to include typescript/javascript; change the install hint to `pipx inject ai-codeindex tree-sitter-<lang> [tree-sitter-<lang2>...]` (matches the rest of the doc surface). New structural test `test_parser_package_map_covers_scanner_supported_set` locks the invariant — adding a language to scanner.py without exposing it via `PARSER_PACKAGES` will fail the test, preventing the GH #86 drift class from recurring (same pattern as the #73 structural guard).
+- **`scan-all --ai` no longer caches AI refusal text as `enrichment: ok`** (GH #85): when the configured AI backend declined to answer for a directory (e.g. haiku returning "I don't see any file names or symbol names provided…"), Phase 2 wrote the refusal verbatim into the directory's `README_AI.md` blockquote AND stamped `<!-- enrichment: ok -->`. Subsequent `scan-all --ai` runs saw the `ok` marker, skipped re-enrichment, and the garbage description stuck in the cache forever. New `enricher.looks_like_refusal(text)` helper detects common refusal prefixes (case-insensitive: `I don't`, `I cannot`, `I'm unable`, `no file`, `insufficient context`, `as an AI`, etc.); when matched, the directory is marked `failed (reason: ai-refused)` so the next run retries automatically (idempotent re-enrichment policy already in place). Refusal-pattern detection happens on the cleaned/truncated AI output (~80 chars) — refusal phrasing always lives in the first ~30 chars so truncation doesn't blind the check.
+- **Post-commit hook now fires on merge commits** (GH #84): the shell wrapper's loop guard used `git diff-tree --no-commit-id --name-only -r HEAD`, which returns **empty on merge commits** by default — `-m` is required to enumerate per-parent changes. Empty → `NON_DOC_FILES` empty → wrapper exits 0 without delegating to `codeindex hooks run post-commit`. Net effect on GitFlow projects: `README_AI.md` files never auto-updated on PR merges (the commits that actually bring new code to `main` / `develop`). Reported live on fabricOS HEAD `171702b` (Merge PR #7). Fix: add `-m` to the diff-tree command. Verified against a real merge commit in this repo (`e240ba0` — Merge develop for 0.26.0 release): old logic saw 0 files, new logic sees the 20 files actually changed. New regression test in `tests/test_cli_hooks.py::TestHookGeneration::test_post_commit_loop_guard_handles_merge_commits` locks both directions (rejects the broken pattern, requires either `-m` or `git show --name-only`).
+
 ## [0.26.0] - 2026-06-01
 
 **Theme**: dogfood-driven CLI bug sweep. Five user-reported issues from fabricOS dogfood — mostly UX cliffs in `init` and `list-dirs` on non-Python projects, plus a navigation-correctness bug in nav-level `README_AI.md`. One contract change in `init --yes` so first `scan-all --ai` works out of the box.

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-codeindex
-Version: 0.26.0
+Version: 0.26.1
 Summary: AI-native code indexing tool for large codebases
 Project-URL: Homepage, https://github.com/dreamlx/codeindex
 Project-URL: Documentation, https://github.com/dreamlx/codeindex

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ai-codeindex"
-version = "0.26.0"
+version = "0.26.1"
 description = "AI-native code indexing tool for large codebases"
 readme = "README.md"
 requires-python = ">=3.10"

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/src/codeindex/README_AI.md

@@ -1,12 +1,12 @@
 <!-- codeindex navigation index — agent: drill into source via Read/Grep for precise mechanism; do not treat this as final word. -->
-<!-- Generated by codeindex (detailed) at 2026-06-01T11:56:26.178371 -->
+<!-- Generated by codeindex (detailed) at 2026-06-05T21:54:59.634399 -->
 
 # codeindex
 
 ## Overview
 
 - **Files**: 89
-- **Symbols**: 570
+- **Symbols**: 572
 
 ## Files
 
@@ -162,7 +162,7 @@ This module provides:
 - `def install_hook(hook_name: str, repo_path: Optional[Path] = None) -> bool`
 - `def uninstall_hook(hook_name: str, repo_path: Optional[Path] = None) -> bool`
 
-_... and 6 more symbols_
+_... and 7 more symbols_
 
 ### cli_parse.py
 _CLI parse command - Parse a single source file and output JSON.

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/src/codeindex/cli_hooks.py

@@ -316,8 +316,11 @@ exit 0
 # Post-commit hook for codeindex
 # Thin wrapper — all logic in Python (auto-updated via pip)
 
-# Avoid infinite loop: skip if last commit only contains README_AI.md
-LAST_COMMIT_FILES=$(git diff-tree --no-commit-id --name-only -r HEAD)
+# Avoid infinite loop: skip if last commit only contains README_AI.md.
+# -m is required so merge commits enumerate per-parent changes — without it
+# `git diff-tree -r HEAD` returns empty on every merge commit and the hook
+# silently skips every PR merge in a GitFlow project (GH #84).
+LAST_COMMIT_FILES=$(git diff-tree --no-commit-id --name-only -r -m HEAD)
 NON_DOC_FILES=$(echo "$LAST_COMMIT_FILES" | \\
     grep -v "README_AI.md" | grep -v "PROJECT_INDEX.md" || true)
 if [ -z "$NON_DOC_FILES" ]; then
@@ -539,6 +542,48 @@ def hooks():
     pass
 
 
+def _maybe_warn_post_commit_disabled(project_dir: Path) -> None:
+    """Print a reminder if ``hooks.post_commit.enabled`` is false in
+    ``.codeindex.yaml``.
+
+    ``codeindex init`` ships the yaml with ``enabled: false`` by default,
+    so the installed ``.git/hooks/post-commit`` wrapper no-ops at runtime
+    even though the install command printed ✓. User commits, READMEs don't
+    update, "it doesn't work" — see GH #87.
+
+    We don't flip the flag automatically (contract change, see #75 for the
+    boundary). The reminder makes the contract visible at install time so
+    the user can decide.
+    """
+    yaml_path = project_dir / ".codeindex.yaml"
+    if not yaml_path.exists():
+        return
+
+    try:
+        import yaml
+
+        with open(yaml_path) as f:
+            data = yaml.safe_load(f) or {}
+    except Exception:
+        # Yaml unreadable or parse error — silent skip; the install itself
+        # succeeded, we don't want this advisory to mask the real result.
+        return
+
+    enabled = data.get("hooks", {}).get("post_commit", {}).get("enabled", False)
+    if enabled:
+        return
+
+    console.print(
+        "[yellow]⚠[/yellow]  [bold]post_commit.enabled is false in "
+        ".codeindex.yaml[/bold] — the installed hook wrapper checks this "
+        "flag at runtime and will no-op until you flip it.\n"
+        "   Edit [cyan].codeindex.yaml[/cyan]:\n"
+        "     hooks:\n"
+        "       post_commit:\n"
+        "         [bold]enabled: true[/bold]\n"
+    )
+
+
 @hooks.command()
 @click.option(
     "--all",
@@ -625,6 +670,13 @@ def install(hook_name: Optional[str], install_all: bool, force: bool):
                 f"[dim]→ Skipped {skipped_count} already installed hook(s)[/dim]\n"
             )
 
+        # GH #87: surface the runtime-disabled trap. If post-commit was just
+        # installed (or was already installed), the wrapper still no-ops when
+        # .codeindex.yaml has post_commit.enabled=false (the init default).
+        # Without this reminder, install prints ✓ but commits trigger nothing.
+        if "post-commit" in hooks_to_install:
+            _maybe_warn_post_commit_disabled(Path.cwd())
+
     except ValueError as e:
         console.print(f"[red]✗[/red] Error: {e}", style="red")
         raise click.Abort()

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/src/codeindex/cli_scan.py

@@ -668,6 +668,7 @@ def _enrich_directories_with_ai(
         build_safe_subdir_context,
         extract_summary_from_readme,
         inject_blockquote,
+        looks_like_refusal,
         mark_enrichment_status,
         should_enrich,
     )
@@ -759,6 +760,20 @@ def _enrich_directories_with_ai(
             failed_dirs.append(dir_path.name)
             continue
 
+        # AI returned text, but is it an actual description or a refusal?
+        # Stamping refusal text with `enrichment: ok` poisons the cache forever
+        # because subsequent runs see the marker and skip re-enrichment (GH #85).
+        if looks_like_refusal(description):
+            if readme_path.exists():
+                mark_enrichment_status(readme_path, "failed", reason="ai-refused")
+            failed_dirs.append(dir_path.name)
+            if not quiet:
+                console.print(
+                    f"[yellow]⚠[/yellow] {dir_path.name}: AI declined "
+                    f"(refusal pattern) — will retry next `scan-all --ai`"
+                )
+            continue
+
         # Inject into README_AI.md
         if readme_path.exists():
             inject_blockquote(readme_path, description)

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/src/codeindex/enricher.py

@@ -18,6 +18,46 @@ _MAX_SYMBOLS_PER_FILE = 5
 # Maximum total files to include in the prompt
 _MAX_FILES = 15
 
+# Refusal prefixes used to detect AI responses that decline to summarise the
+# directory (typically because the prompt context was thin enough that the
+# model can't say anything specific). When the model returns "I don't see any
+# file names..." we must NOT stamp `enrichment: ok` — that poisons the cache
+# permanently (GH #85). Instead the response is treated as a failure with
+# reason "ai-refused" so the next `scan-all --ai` retries automatically.
+#
+# Matched against the lowercased, stripped response. Keep prefixes short so
+# the check is robust to upstream truncation (the cli_scan path truncates
+# enrichment output to ~80 chars; refusal phrasing is always in the first 30).
+_REFUSAL_PREFIXES = (
+    "i don't",
+    "i do not",
+    "i cannot",
+    "i can't",
+    "i'm unable",
+    "i am unable",
+    "i need more",
+    "no file",
+    "insufficient context",
+    "without more",
+    "sorry, i",
+    "as an ai",
+)
+
+
+def looks_like_refusal(text: str) -> bool:
+    """Return True if the cleaned AI response looks like a refusal / inability.
+
+    Used by ``scan-all --ai`` Phase 2 to distinguish a usable one-line
+    description from boilerplate refusal text. The refusal text is never
+    project-information and stamping it with ``<!-- enrichment: ok -->``
+    pins it in the cache; the next run sees the marker and skips
+    re-enrichment, so the garbage description sticks indefinitely (GH #85).
+    """
+    t = (text or "").strip().lower()
+    if not t:
+        return False
+    return any(t.startswith(p) for p in _REFUSAL_PREFIXES)
+
 
 def extract_symbol_summary(parse_results: list[ParseResult]) -> str:
     """Extract a compact summary of file names + symbol names for AI prompt.

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/src/codeindex/init_wizard.py

@@ -94,11 +94,19 @@ FRAMEWORK_PATTERNS: Dict[str, Dict[str, str]] = {
 
 
 
-# Parser package mapping: language -> tree-sitter package name
+# Parser package mapping: language -> tree-sitter Python import name.
+#
+# Must stay in sync with ``scanner.LANGUAGE_EXTENSIONS``. The structural
+# test ``test_parser_package_map_covers_scanner_supported_set`` locks the
+# invariant — adding a language to scanner.py without exposing it here
+# silently re-introduces the GH #86 false-positive ("missing parsers" for
+# parsers that are actually installed).
 PARSER_PACKAGES = {
     "python": "tree_sitter_python",
     "php": "tree_sitter_php",
     "java": "tree_sitter_java",
+    "typescript": "tree_sitter_typescript",
+    "javascript": "tree_sitter_javascript",
 }
 
 
@@ -146,8 +154,13 @@ def get_parser_install_guidance(languages: list[str]) -> dict:
     }
 
     if missing:
-        extras = ",".join(missing)
-        result["install_command"] = f"pip install ai-codeindex[{extras}]"
+        # Use `pipx inject ai-codeindex tree-sitter-<lang>` to match the
+        # documented install path (CLAUDE.md, README, hooks/index SKILL all
+        # use pipx). The previous `pip install ai-codeindex[<lang>]` hint
+        # contradicted the recommended path AND broke for pipx-managed
+        # envs — see GH #86 (4b).
+        pkgs = " ".join(f"tree-sitter-{lang}" for lang in missing)
+        result["install_command"] = f"pipx inject ai-codeindex {pkgs}"
 
     return result
 

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/tests/README_AI.md

@@ -1,12 +1,12 @@
 <!-- codeindex navigation index — agent: drill into source via Read/Grep for precise mechanism; do not treat this as final word. -->
-<!-- Generated by codeindex (detailed) at 2026-06-01T11:59:55.553144 -->
+<!-- Generated by codeindex (detailed) at 2026-06-05T21:54:59.931951 -->
 
 # tests
 
 ## Overview
 
 - **Files**: 125
-- **Symbols**: 2148
+- **Symbols**: 2164
 
 ## Files
 

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/tests/test_cli_hooks.py

@@ -223,6 +223,40 @@ class TestHookGeneration:
 
         assert "codeindex-managed hook" in script
 
+    def test_post_commit_loop_guard_handles_merge_commits(self):
+        """Regression for GH #84.
+
+        ``git diff-tree --no-commit-id --name-only -r HEAD`` returns empty
+        on merge commits by default — it needs ``-m`` to enumerate the
+        per-parent changes. Without the flag, the loop guard sees zero
+        files on every merge commit, hits the "all docs" early-exit, and
+        the wrapper never delegates to ``codeindex hooks run post-commit``.
+
+        Net effect on GitFlow projects: ``README_AI.md`` files never
+        auto-update on PR merges (the commits that bring new code to
+        ``main`` / ``develop``). Reported live on fabricOS HEAD ``171702b``.
+        """
+        script = generate_hook_script("post-commit")
+
+        # The broken pattern: -r HEAD without -m. Asserted as a literal
+        # substring so future whitespace/format tweaks don't accidentally
+        # let it back in.
+        assert "diff-tree --no-commit-id --name-only -r HEAD" not in script, (
+            "Post-commit loop guard uses `git diff-tree -r HEAD` without -m. "
+            "On merge commits this returns empty and the hook silently skips "
+            "(GH #84). Use `-m` or `git show --name-only`."
+        )
+
+        # The fix: either -m on diff-tree OR git show --name-only. Both
+        # produce non-empty output on merge commits.
+        has_dash_m = "diff-tree" in script and " -m " in script
+        has_git_show = "git show --name-only" in script
+        assert has_dash_m or has_git_show, (
+            "Post-commit hook must enumerate files on merge commits. "
+            "Expected either `git diff-tree ... -m HEAD` or "
+            "`git show --name-only ... HEAD` in the loop guard (GH #84)."
+        )
+
 
 class TestBackupAndRestore:
     """Test backup and restore functionality."""
@@ -297,3 +331,85 @@ class TestCLIIntegration:
         """Should provide hooks status CLI command."""
         # This will be implemented with Click
         pass
+
+
+class TestPostCommitEnabledWarning:
+    """GH #87 — ``codeindex hooks install post-commit`` must surface the
+    runtime-disabled trap.
+
+    ``codeindex init`` writes ``.codeindex.yaml`` with
+    ``hooks.post_commit.enabled: false`` by default. Without a reminder at
+    install time, users see the install ✓, make commits, and nothing
+    happens because the wrapper checks the flag at runtime. These tests
+    cover the three meaningful states (disabled / enabled / no yaml)."""
+
+    def _yaml(self, enabled: bool) -> str:
+        return (
+            "version: 1\n"
+            "hooks:\n"
+            "  post_commit:\n"
+            f"    enabled: {str(enabled).lower()}\n"
+        )
+
+    def test_install_warns_when_yaml_disables_post_commit(self, tmp_path):
+        from click.testing import CliRunner
+
+        from codeindex.cli import main
+
+        (tmp_path / ".git" / "hooks").mkdir(parents=True)
+        (tmp_path / ".codeindex.yaml").write_text(self._yaml(enabled=False))
+
+        runner = CliRunner()
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(tmp_path)
+            result = runner.invoke(main, ["hooks", "install", "post-commit"])
+        finally:
+            os.chdir(original_cwd)
+
+        assert result.exit_code == 0, result.output
+        assert "post_commit.enabled is false" in result.output, result.output
+        # The user-visible fix (the yaml snippet) must be present.
+        assert "enabled: true" in result.output
+
+    def test_install_silent_when_yaml_enables_post_commit(self, tmp_path):
+        from click.testing import CliRunner
+
+        from codeindex.cli import main
+
+        (tmp_path / ".git" / "hooks").mkdir(parents=True)
+        (tmp_path / ".codeindex.yaml").write_text(self._yaml(enabled=True))
+
+        runner = CliRunner()
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(tmp_path)
+            result = runner.invoke(main, ["hooks", "install", "post-commit"])
+        finally:
+            os.chdir(original_cwd)
+
+        assert result.exit_code == 0, result.output
+        # No reminder when the user has explicitly enabled it.
+        assert "post_commit.enabled is false" not in result.output
+
+    def test_install_silent_when_no_yaml(self, tmp_path):
+        """Without ``.codeindex.yaml`` we don't know the project's intent;
+        the install itself succeeds, advisory stays silent — matches the
+        rule "don't mask the real result of a non-yaml-driven command"."""
+        from click.testing import CliRunner
+
+        from codeindex.cli import main
+
+        (tmp_path / ".git" / "hooks").mkdir(parents=True)
+        # No .codeindex.yaml.
+
+        runner = CliRunner()
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(tmp_path)
+            result = runner.invoke(main, ["hooks", "install", "post-commit"])
+        finally:
+            os.chdir(original_cwd)
+
+        assert result.exit_code == 0, result.output
+        assert "post_commit.enabled is false" not in result.output

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/tests/test_enricher.py

@@ -14,6 +14,7 @@ from codeindex.enricher import (
     extract_symbol_summary,
     has_successful_enrichment,
     inject_blockquote,
+    looks_like_refusal,
     mark_enrichment_status,
     should_enrich,
 )
@@ -417,3 +418,75 @@ class TestMarkEnrichmentStatus:
             line for line in content.split("\n") if line.startswith("<!-- enrichment:")
         ][0]
         assert "line2" not in enrichment_line or "\n" not in enrichment_line
+
+
+class TestLooksLikeRefusal:
+    """Tests for the GH #85 refusal detector."""
+
+    def test_classic_refusal_patterns(self):
+        """Phrases observed on fabricOS haiku enrichment failures."""
+        # The exact phrase that prompted the bug report:
+        assert looks_like_refusal(
+            "I don't see any file names or symbol names provided in the directory listing"
+        )
+        assert looks_like_refusal("I cannot provide a description without more context")
+        assert looks_like_refusal("I'm unable to summarise this module")
+        assert looks_like_refusal("I am unable to identify the purpose")
+        assert looks_like_refusal("I need more information to describe this")
+        assert looks_like_refusal("No file names were provided")
+        assert looks_like_refusal("Insufficient context to summarise")
+        assert looks_like_refusal("Sorry, I can't help with that")
+        assert looks_like_refusal("As an AI language model, I can't...")
+
+    def test_case_insensitive_and_whitespace_tolerant(self):
+        assert looks_like_refusal("  I DON'T see any files  ")
+        assert looks_like_refusal("\n\ni cannot help\n")
+        assert looks_like_refusal("I Don't Have Enough Info")
+
+    def test_normal_descriptions_are_not_refusals(self):
+        """Real one-line descriptions must pass through unmolested."""
+        assert not looks_like_refusal("会员等级管理、积分兑换、权益卡券")
+        assert not looks_like_refusal("Identity and authentication layer")
+        assert not looks_like_refusal("HTTP request handlers and middleware")
+        assert not looks_like_refusal("Data access layer (repositories + ORM)")
+        # English description that mentions "I" but isn't a refusal:
+        assert not looks_like_refusal("Implementation of OAuth2 flows")
+
+    def test_empty_and_whitespace_only(self):
+        # Empty / whitespace-only is handled by the existing "empty AI
+        # response" branch in cli_scan; the refusal check should NOT also
+        # claim it (avoid double-classification).
+        assert not looks_like_refusal("")
+        assert not looks_like_refusal("   ")
+        assert not looks_like_refusal("\n\n\t")
+        assert not looks_like_refusal(None)  # type: ignore[arg-type]
+
+
+class TestRefusalEndToEndMarker:
+    """GH #85 — refusal text must end up as `failed (ai-refused)`, never `ok`.
+
+    Mirrors the cli_scan Phase 2 decision branch: after cleaning the AI
+    response, the loop chooses between (empty / refused / ok). This test
+    drives the same conditional with a refusal sample and asserts the
+    on-disk marker + blockquote state.
+    """
+
+    def test_refusal_text_marks_failed_not_ok(self, tmp_path):
+        readme = tmp_path / "README_AI.md"
+        readme.write_text("# ui\n\n## Overview\n")
+        description = "I don't see any file names or symbol names provided"
+
+        # Same branch order as cli_scan._enrich_directories_with_ai:
+        if not description:
+            mark_enrichment_status(readme, "failed", reason="empty AI response")
+        elif looks_like_refusal(description):
+            mark_enrichment_status(readme, "failed", reason="ai-refused")
+        else:
+            inject_blockquote(readme, description)
+            mark_enrichment_status(readme, "ok")
+
+        content = readme.read_text()
+        assert "<!-- enrichment: failed (reason: ai-refused) -->" in content
+        assert "<!-- enrichment: ok -->" not in content
+        # Blockquote MUST NOT be injected — refusal text is not a description.
+        assert "I don't see" not in content

{ai_codeindex-0.26.0 → ai_codeindex-0.26.1}/tests/test_parser_detection.py

@@ -56,6 +56,71 @@ class TestParserInstallGuidance:
         assert guidance["missing"] == []
         assert guidance["installed"] == []
 
+    def test_typescript_javascript_are_known_to_parser_map(self):
+        """Regression for GH #86 (4a).
+
+        ``PARSER_PACKAGES`` used to enumerate only python/php/java, even
+        though scanner gained TS/JS parsers (#73) and the parser modules
+        exist under ``src/codeindex/parsers/typescript/`` and
+        ``.../javascript/``. Result: ``init --yes`` on a TS project
+        reported ``Warning: Missing parsers for: javascript, typescript``
+        even though ``pipx inject ai-codeindex tree-sitter-{typescript,
+        javascript}`` confirmed the packages were already installed.
+
+        With the fix, TS/JS must be detected as installed in dev/CI
+        (where ``[all]`` extra is installed via ``pip install -e .[dev,all]``).
+        """
+        assert check_parser_installed("typescript") is True
+        assert check_parser_installed("javascript") is True
+
+        guidance = get_parser_install_guidance(["typescript", "javascript"])
+        assert "typescript" in guidance["installed"]
+        assert "javascript" in guidance["installed"]
+        assert "typescript" not in guidance["missing"]
+        assert "javascript" not in guidance["missing"]
+
+    def test_install_command_uses_pipx_inject_not_pip_install(self):
+        """Regression for GH #86 (4b).
+
+        The hint used to be ``pip install ai-codeindex[<langs>]`` — contradicts
+        the entire documented install path (``pipx install ai-codeindex`` is the
+        recommended path per CLAUDE.md / README / both hooks & index SKILL).
+        Worse: ``pip install`` into a pipx-managed env doesn't work cleanly,
+        so the hint actively misleads.
+
+        Force a missing parser by asking for an unknown language; assert the
+        hint now uses ``pipx inject``.
+        """
+        guidance = get_parser_install_guidance(["fortran"])
+        assert "install_command" in guidance
+        cmd = guidance["install_command"]
+        assert cmd.startswith("pipx inject ai-codeindex"), (
+            f"Install hint must point to pipx (not pip install); got: {cmd!r}"
+        )
+        assert "pip install" not in cmd, (
+            f"Install hint still mentions `pip install` — contradicts pipx-based "
+            f"recommended path (GH #86 4b). Got: {cmd!r}"
+        )
+
+    def test_parser_package_map_covers_scanner_supported_set(self):
+        """Structural drift guard. ``PARSER_PACKAGES`` (used to validate
+        installed parsers + build install hints) must cover every language
+        ``scanner.LANGUAGE_EXTENSIONS`` knows how to scan — otherwise a
+        language can be detected by ``init`` (#73) and scanned by the
+        runtime, while the parser-presence check silently fails for it,
+        re-introducing the GH #86 false-positive warning class."""
+        from codeindex.init_wizard import PARSER_PACKAGES
+        from codeindex.scanner import LANGUAGE_EXTENSIONS as SCAN_EXT
+
+        missing = set(SCAN_EXT.keys()) - set(PARSER_PACKAGES.keys())
+        assert not missing, (
+            f"init_wizard.PARSER_PACKAGES is missing languages that "
+            f"scanner.py knows how to scan: {sorted(missing)}. This is the "
+            f"drift class that caused GH #86 — the parser-installed check "
+            f"silently returns False for these and `init` warns about "
+            f"\"missing parsers\" even when they're installed."
+        )
+
 
 class TestInitWizardPostMessage:
     """Tests for updated post-init messages (Story 19.2)."""