ki-manager 2.3.0.dev3__tar.gz → 2.3.1__tar.gz

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/.gitignore

@@ -29,3 +29,6 @@ posts/
 
 # Private plans (moved to KI-enterprise)
 plans/
+
+# Agent/MCP state
+.serena/

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/CHANGELOG.md

@@ -9,7 +9,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [2.3.0.dev3] — 2026-10-09
+## [2.3.1] — 2026-10-18
+
+### Security & Hardening
+- **Path Traversal Protection**: Enforced strict directory boundary containment across all file discovery and inspection tools (`find_unmapped_files`, `analyze_module`, `ki_search`, and custom agent paths) to prevent prefix-based sandbox traversal attacks.
+- **Secured Git Operations (`git_diff_secured`)**: Added hardened diff inspection tool protecting against flag injection (`--output`, etc.), shell command chaining, and repository boundary escapes.
+- **Restricted File Modifications**: Extended write protection to block direct modifications of shell/executable scripts (`.sh`, `.bash`, `.zsh`, `.js`, `.ts`, `.vbs`, `.wsf`) and internal system state files (`doc_config.json`, `ki_config.json`, `config.json`, `doc_state.json`) via direct file editing tools.
+
+### Changed
+- **Unified Tool Dispatch Schema**: In compact facade mode, dynamically bind `ki_call` and `ki_mutate` tool validation schemas (`enum` and `description`) directly to tool `readOnlyHint` annotations, eliminating dispatch conflicts and preventing model confusion.
+- **Date Format Resilience in `update_last_verified`**: Extended `update_last_verified` to automatically detect and update all supported date notation variants (HTML comment `<!-- last_verified: YYYY-MM-DD -->`, YAML frontmatter `last_verified: "YYYY-MM-DD"`, and Markdown bold `**Last verified**: YYYY-MM-DD`), and automatically insert the verification tag if missing.
+- **Workflow Instructions Alignment**: Synchronized tool arguments and signatures across `/expand-knowledge` and `/sync-knowledge` instructions, ensuring seamless execution in both compact facade and full tool modes.
+- **Daily MCP Log Rotation**: Server diagnostics now rotate daily (`mcp_YYYY-MM-DD.log`) with payload truncation to prevent runaway disk usage during high-frequency sessions.
+
+## [2.3.0] — 2026-10-11
+
+### Added
+- **Unified Cascade Path Resolution (`resolve_know_path`)**: `read_know_file`, `write_know_file`, and `edit_know_file` now share `ki_read`'s smart cascade resolver. AI agents can access and edit Knowledge Items using flat basenames (e.g. `KI_data_persistence.md`) without requiring explicit `knowledge/` directory prefixes.
+- **Smart Directory Placement for New KIs**: `write_know_file` now updates existing files in place across `knowledge/` rather than creating duplicates in the sandbox root, and automatically routes newly created flat KI files (`KI_*.md`, `*.ki.md`) into `<jail>/knowledge/`.
+- **ADR Name & Prefix Tolerance**: `resolve_know_path` and `ki_read` gracefully handle variations with or without `ADR_`/`adr_`/`ADR-` prefixes (e.g., resolving `ADR_002_node_status_queue_and_ui_feedback.md` to `002_node_status_queue_and_ui_feedback.md`) as well as numeric ADR IDs.
+- **Accurate Document Listings**: `get_ki_list_table()` dynamically reconciles registered entries in `doc_config.json` against filesystem reality, outputting exact on-disk filenames in document overviews.
+- **Comprehensive Project Overview**: `ki_instructions(document="knowledge-items")`, prompts, and `ki://knowledge-items.md` now present both Knowledge Items and Architecture Decision Records (ADRs) tables together when ADRs exist.
+
+### Highlights from 2.3.0 Development Cycle
+- Compact Facade Mode (`--tool-mode compact`) reducing MCP tools footprint from 34 schemas to 6 tools (`ki_instructions`, `ki_search`, `ki_read`, `ki_tools`, `ki_call`, `ki_mutate`), saving thousands of context tokens.
+- Native BM25 search engine (`ki_search`) with bilingual EN/RU stemming and field-weighted ranking.
+- Token-efficient reader with section filtering and character offset pagination (`ki_read`, `read_know_file`).
+- Batch ADR superseding (`create_adr`) with automatic status transitions, warning banners, git/environment snapshots, and quality sections (`rejected_alternatives`, `invariants`, `verification`).
+- Automated drift analysis (`check_ki_drift`) and Python AST pre-enrichment during scaffolding.
 
 ### Added
 - `create_adr` batch `supersedes` support: accept a list of previous ADR IDs (`supersedes: ["001", "002"]`) to supersede multiple older records simultaneously; automatically updates deprecated ADR files with warning banners and `Superseded by ADR XXX` statuses, updates `doc_config.json`, and embeds bi-directional cross-links in the generated ADR.

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ki-manager
-Version: 2.3.0.dev3
+Version: 2.3.1
 Summary: Knowledge Item (KI) management MCP server for AI-assisted development
 Project-URL: Homepage, https://github.com/Laeryid/KI-base
 Project-URL: Repository, https://github.com/Laeryid/KI-base

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ki-manager"
-version = "2.3.0.dev3"
+version = "2.3.1"
 description = "Knowledge Item (KI) management MCP server for AI-assisted development"
 readme = "README.md"
 license = { file = "LICENSE" }

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/__init__.py

@@ -1,3 +1,3 @@
 
 """ki-manager — Knowledge Item MCP server for AI-assisted development."""
-__version__ = "2.3.0.dev3"
+__version__ = "2.3.1"

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/cli.py

@@ -144,11 +144,14 @@ def main():
     if command == "install-skills":
         install_skills(sys.argv[2:])
     elif command in ("--version", "-v"):
-        import importlib.metadata
         try:
-            v = importlib.metadata.version("ki-manager")
+            from . import __version__ as v
         except Exception:
-            v = "unknown"
+            import importlib.metadata
+            try:
+                v = importlib.metadata.version("ki-manager")
+            except Exception:
+                v = "unknown"
         print(f"ki-manager {v}")
         sys.exit(0)
     else:

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/scripts/analyze_module.py

@@ -32,6 +32,9 @@ def analyze_path(target_path: str, recursive: bool = False):
     
     # Resolve absolute path
     abs_target = os.path.normpath(os.path.join(project_root, target_path))
+    if not ki_utils.is_subpath(abs_target, project_root):
+        print(f"Error: Path '{target_path}' escapes project root.")
+        return
 
     if not os.path.exists(abs_target):
         print(f"Error: Path {target_path} not found.")

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/scripts/audit_coverage.py

@@ -65,7 +65,7 @@ def load_ki_files() -> list:
     ki_dir = os.path.join(get_knowledge_root(), "knowledge")
     if not os.path.isdir(ki_dir):
         return []
-    return [f for f in os.listdir(ki_dir) if f.startswith("KI_") and f.endswith(".md")]
+    return [f for f in os.listdir(ki_dir) if ki_utils.is_ki_filename(f)]
 
 
 # ─── Metrics ──────────────────────────────────────────────────────────────────

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/scripts/check_ki_drift.py

@@ -286,7 +286,7 @@ def run_drift_check(
         return [check_single_ki(target_name, target_path, doc_config, project_root, knowledge_dir)]
 
     results = []
-    for f in sorted(knowledge_dir.glob("KI_*.md")):
+    for f in sorted(f for f in knowledge_dir.glob("*.md") if ki_utils.is_ki_filename(f.name)):
         results.append(check_single_ki(f.name, f, doc_config, project_root, knowledge_dir))
 
     return results

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/scripts/finalize_ki_scaffolds.py

@@ -70,7 +70,7 @@ def finalize_scaffolds(dry_run: bool = False) -> None:
     skipped_clean = 0
 
     for fname in sorted(os.listdir(ki_dir)):
-        if not (fname.startswith("KI_") and fname.endswith(".md")):
+        if not ki_utils.is_ki_filename(fname):
             continue
 
         ki_path = os.path.join(ki_dir, fname)

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/scripts/find_unmapped_files.py

@@ -29,6 +29,8 @@ def get_unmapped_files(target_path: str = ".") -> List[str]:
 
     # 2. Scan the target directory
     abs_target = os.path.abspath(os.path.join(project_root, target_path))
+    if not ki_utils.is_subpath(abs_target, project_root):
+        return []
     if not os.path.exists(abs_target):
         return []
 

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/scripts/generate_ki_scaffolds.py

@@ -514,7 +514,7 @@ def print_scaffold_status() -> None:
     enriched_count = 0
     
     for fname in sorted(os.listdir(ki_dir)):
-        if not (fname.startswith("KI_") and fname.endswith(".md")):
+        if not ki_utils.is_ki_filename(fname):
             continue
             
         ki_path = os.path.join(ki_dir, fname)

ki_manager-2.3.1/src/ki_manager/scripts/git_diff_secured.py

@@ -0,0 +1,81 @@
+"""
+git_diff_secured.py
+
+Safely runs git status and git diff for project files within the project sandbox.
+Prevents argument/flag injection and path traversal.
+"""
+
+import os
+import sys
+import argparse
+import subprocess
+from pathlib import Path
+from typing import List
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import ki_utils
+
+
+def git_diff_secured(paths: List[str] = None) -> str:
+    project_root = ki_utils.get_project_root()
+    if not project_root or not os.path.exists(project_root):
+        return "Error: No active project context."
+
+    safe_paths = []
+    if paths:
+        for p in paths:
+            clean_p = p.strip()
+            if not clean_p:
+                continue
+            if clean_p.startswith("-") or any(char in clean_p for char in [";", "|", "&", ">", "<", "`"]):
+                return f"Error: Suspicious argument or path '{clean_p}'."
+            abs_p = os.path.abspath(os.path.join(project_root, clean_p))
+            if not ki_utils.is_subpath(abs_p, project_root):
+                return f"Access Denied: Path '{clean_p}' escapes project root."
+            safe_paths.append(os.path.relpath(abs_p, project_root).replace("\\", "/"))
+
+    try:
+        if safe_paths:
+            stat_cmd = ["git", "status", "--short", "--"] + safe_paths
+            diff_cmd = ["git", "diff", "HEAD", "--"] + safe_paths
+        else:
+            stat_cmd = ["git", "status", "--short"]
+            diff_cmd = ["git", "diff", "HEAD"]
+
+        stat_res = subprocess.run(
+            stat_cmd, cwd=project_root, capture_output=True, text=True, encoding="utf-8"
+        )
+        diff_res = subprocess.run(
+            diff_cmd, cwd=project_root, capture_output=True, text=True, encoding="utf-8"
+        )
+
+        output = []
+        if stat_res.stdout.strip():
+            output.append("### Git Status:\n" + stat_res.stdout.strip())
+        if diff_res.stdout.strip():
+            output.append("### Git Diff:\n" + diff_res.stdout.strip())
+        if not output:
+            output.append("No changes detected in git.")
+
+        return "\n\n".join(output)
+    except Exception as e:
+        return f"Git execution error: {str(e)}"
+
+
+def main():
+    if sys.platform == "win32":
+        try:
+            sys.stdout.reconfigure(encoding="utf-8")
+        except Exception:
+            pass
+
+    parser = argparse.ArgumentParser(description="Secured git diff for project files.")
+    parser.add_argument("paths", nargs=argparse.REMAINDER, help="File or directory paths relative to project root")
+    args = parser.parse_args()
+
+    result = git_diff_secured(args.paths)
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/scripts/ki_search.py

@@ -218,7 +218,7 @@ def search_knowledge(
         return {"error": "No project root found. Run ki_init_project or specify workspace.", "results": []}
 
     knowledge_root = ki_utils.get_knowledge_root()
-    if not knowledge_root or not os.path.exists(knowledge_root) or not os.path.normcase(os.path.abspath(knowledge_root)).startswith(os.path.normcase(os.path.abspath(project_root))):
+    if not knowledge_root or not os.path.exists(knowledge_root) or not ki_utils.is_subpath(knowledge_root, project_root):
         for cand in [
             os.path.join(project_root, ".ki-base", "knowledge"),
             os.path.join(project_root, "knowledge"),

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/scripts/ki_utils.py

@@ -58,6 +58,28 @@ def normalize_path(path_str: str, make_absolute: bool = True) -> str:
     return path_str
 
 
+def is_subpath(target: str, root: str) -> bool:
+    """Checks whether target path is strictly within or equal to root directory."""
+    if not target or not root:
+        return False
+    try:
+        norm_t = os.path.normcase(os.path.abspath(target))
+        norm_r = os.path.normcase(os.path.abspath(root))
+        return os.path.commonpath([norm_t, norm_r]) == norm_r
+    except (ValueError, OSError):
+        return False
+
+
+def is_ki_filename(name: str, include_overview: bool = False) -> bool:
+    """Checks if a file name matches Knowledge Item convention (KI_*.md or *.ki.md)."""
+    if not name or not name.endswith(".md"):
+        return False
+    base = os.path.basename(name)
+    if not include_overview and base in ("_OVERVIEW.ki.md", "_OVERVIEW.md"):
+        return False
+    return base.startswith("KI_") or base.endswith(".ki.md")
+
+
 # ─── Registry Management ─────────────────────────────────────────────────────
 
 def get_registry_path() -> Path:
@@ -139,7 +161,7 @@ def find_project_by_cwd(cwd=None) -> dict:
 
     for proj_root, data in registry["projects"].items():
         norm_proj = normalize_path(proj_root)
-        if os.path.normcase(cwd).startswith(os.path.normcase(norm_proj)):
+        if is_subpath(cwd, norm_proj):
             if len(norm_proj) > max_len:
                 max_len = len(norm_proj)
                 best_match = data
@@ -409,10 +431,30 @@ def get_ki_list_table() -> str:
     items = doc_config.get("knowledge_items", {})
     if not items:
         return "No Knowledge Items registered yet."
+    jail = get_knowledge_root()
+    proj = get_project_root()
+    dec_dirs = get_decisions_dirs(proj, jail)
+
     rows = ["| File | Topic / Summary |", "|------|-----------------|"]
     for name, info in sorted(items.items()):
         summary = info.get("summary", info.get("description", "—"))
-        rows.append(f"| `{name}` | {summary} |")
+        display_name = name
+        if "path" in info and info["path"]:
+            display_name = info["path"]
+        elif jail or proj:
+            # Check if name exists literally
+            exists_literal = False
+            for root_cand in ([jail] if jail else []) + dec_dirs:
+                if os.path.exists(os.path.join(root_cand, name)) or os.path.exists(os.path.join(root_cand, "knowledge", name)):
+                    exists_literal = True
+                    break
+            if not exists_literal and re.match(r"^(?:ADR|adr)[_\-]", name):
+                stripped = re.sub(r"^(?:ADR|adr)[_\-]", "", name)
+                for d in dec_dirs:
+                    if os.path.exists(os.path.join(d, stripped)):
+                        display_name = stripped
+                        break
+        rows.append(f"| `{display_name}` | {summary} |")
     return "\n".join(rows)
 
 

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/scripts/knowledge_engine.py

@@ -201,11 +201,11 @@ class KnowledgeEngine:
         if not knowledge_dir.exists():
             return "Knowledge directory not found"
 
-        path_pattern = re.compile(r"`((?:app|ui|extensions|\.know|\.agent|scripts|tests)/[a-zA-Z0-9_\-\./]+)`")
+        path_pattern = re.compile(r"`([a-zA-Z0-9_\-\.]+/[a-zA-Z0-9_\-\./]+)`")
         
         updated_count = 0
         for filename in os.listdir(knowledge_dir):
-            if not filename.endswith(".md"):
+            if not ki_utils.is_ki_filename(filename, include_overview=True):
                 continue
                 
             ki_path = knowledge_dir / filename
@@ -215,8 +215,9 @@ class KnowledgeEngine:
             mentioned = path_pattern.findall(content)
             valid_paths = set()
             for p in mentioned:
-                p = p.rstrip(".,")
-                if (self.project_root / p).exists():
+                p = p.rstrip(".,;:)")
+                target_file = (self.project_root / p).resolve()
+                if ki_utils.is_subpath(str(target_file), str(self.project_root)) and target_file.exists():
                     valid_paths.add(p.replace("\\", "/"))
 
             if filename not in ki_items:

{ki_manager-2.3.0.dev3 → ki_manager-2.3.1}/src/ki_manager/scripts/sync_agents_md.py

@@ -16,12 +16,16 @@ import ki_utils
 
 
 def resolve_agents_path(agents_path: str = None) -> str:
-    """Finds the AGENTS.md file in the project."""
     if agents_path:
         p = ki_utils.normalize_path(agents_path)
-        if os.path.exists(p):
-            return p
-        return p  # let caller handle not found
+        pr = ki_utils.get_project_root()
+        kr = ki_utils.get_knowledge_root()
+        allowed = [pr] if pr else []
+        if kr and kr not in allowed:
+            allowed.append(kr)
+        if allowed and not any(ki_utils.is_subpath(p, r) for r in allowed):
+            return ""
+        return p
 
     pr = ki_utils.get_project_root()
     kr = ki_utils.get_knowledge_root()