context-forge-local 1.0.0__tar.gz

context_forge_local-1.0.0/.gitignore

@@ -0,0 +1,44 @@
+# Virtual environment
+.venv/
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Testing
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+
+# Ruff
+.ruff_cache/
+
+# Build / packaging
+build/
+dist/
+*.egg-info/
+
+# Environment / secrets
+.env
+.env.*
+!.env.example
+
+# IDE
+.vscode/
+.idea/
+
+# macOS
+.DS_Store
+
+# Local project data
+data/
+.context_forge*.db
+
+#other test files
+tp*.py
+tp*.md
+tp*.txt
+/docs/
+/tp_docs/

context_forge_local-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VEX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

context_forge_local-1.0.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.5
+Name: context-forge-local
+Version: 1.0.0
+Summary: Deterministic, local-first repository intelligence and memory vault for Python projects.
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Context Forge
+
+Context Forge is a deterministic, local-first repository intelligence and a memory vault for Python projects.
+
+It helps developers understand codebases by analyzing repository structure, relationships, and code context through a command-line interface.
+
+## Installation
+
+### Using uv
+
+Install Context Forge as a standalone CLI tool:
+
+```bash
+uv tool install context-forge-local
+```
+
+### Using pip
+
+Install Context Forge inside an active Python virtual environment:
+
+```bash
+python -m pip install context-forge-local
+```
+
+**Requirements:** Python 3.13 or newer.
+
+## Usage
+
+Context Forge provides two command names:
+
+```bash
+cf --help
+```
+
+or
+
+```bash
+context-forge --help
+```
+
+Use the help output to explore the available commands and options.
+
+## Design Principles
+
+- **Local-first:** Designed to work locally with your repositories.
+- **Deterministic:** Aims to produce consistent results for the same inputs and repository state.
+- **Repository-aware:** Analyzes project structure and code relationships.
+- **Developer-focused:** Provides command-line tools for repository intelligence and code context.
+
+## License
+
+See the `LICENSE` file for licensing information.

context_forge_local-1.0.0/README.md

@@ -0,0 +1,52 @@
+# Context Forge
+
+Context Forge is a deterministic, local-first repository intelligence and a memory vault for Python projects.
+
+It helps developers understand codebases by analyzing repository structure, relationships, and code context through a command-line interface.
+
+## Installation
+
+### Using uv
+
+Install Context Forge as a standalone CLI tool:
+
+```bash
+uv tool install context-forge-local
+```
+
+### Using pip
+
+Install Context Forge inside an active Python virtual environment:
+
+```bash
+python -m pip install context-forge-local
+```
+
+**Requirements:** Python 3.13 or newer.
+
+## Usage
+
+Context Forge provides two command names:
+
+```bash
+cf --help
+```
+
+or
+
+```bash
+context-forge --help
+```
+
+Use the help output to explore the available commands and options.
+
+## Design Principles
+
+- **Local-first:** Designed to work locally with your repositories.
+- **Deterministic:** Aims to produce consistent results for the same inputs and repository state.
+- **Repository-aware:** Analyzes project structure and code relationships.
+- **Developer-focused:** Provides command-line tools for repository intelligence and code context.
+
+## License
+
+See the `LICENSE` file for licensing information.

context_forge_local-1.0.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "context-forge-local"
+version = "1.0.0"
+description = "Deterministic, local-first repository intelligence and memory vault for Python projects."
+readme = "README.md"
+requires-python = ">=3.13"
+license = "MIT"
+dependencies = []
+
+[project.scripts]
+context-forge = "context_forge.main:main"
+cf = "context_forge.main:main"
+
+[dependency-groups]
+dev = [
+    "pytest",
+    "ruff",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/context_forge"]
+exclude = [
+    "**/.DS_Store",
+    "**/__pycache__/**",
+    "**/*.py[cod]",
+]
+
+[tool.hatch.build.targets.sdist]
+only-include = [
+    "LICENSE",
+    "README.md",
+    "pyproject.toml",
+    "src/context_forge",
+]
+
+[tool.ruff]
+line-length = 88
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+markers = [
+    "integration: tests requiring external services",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"test-projects/full_projects/01_task_management/src/task_mgmt/repositories/base.py" = ["UP046"]

context_forge_local-1.0.0/src/context_forge/__init__.py

@@ -0,0 +1 @@
+

context_forge_local-1.0.0/src/context_forge/application/__init__.py

@@ -0,0 +1,11 @@
+from context_forge.application.factory import (
+    build_context_engine,
+    build_context_service,
+)
+from context_forge.application.service import RepositoryContextService
+
+__all__ = [
+    "RepositoryContextService",
+    "build_context_engine",
+    "build_context_service",
+]

context_forge_local-1.0.0/src/context_forge/application/factory.py

@@ -0,0 +1,69 @@
+from context_forge.application.service import RepositoryContextService
+from context_forge.context import (
+    CandidateGenerator,
+    ContextAssembler,
+    ContextBudgetCompressor,
+    ContextCompressionPipeline,
+    ContextEnrichmentPipeline,
+    ContextPackageBuilder,
+    ContextPriorityOrdering,
+    ContextSelector,
+    DefaultContextEngine,
+    DeterministicContextCompressor,
+    DeterministicPrioritizer,
+    DeterministicRanker,
+    FileContextEnricher,
+    GraphExpander,
+    RelationshipContextEnricher,
+    SymbolContextEnricher,
+)
+from context_forge.context.depth import ContextDepthSelector
+from context_forge.task import (
+    TaskGroundingService,
+    TaskRepositoryGroundingService,
+    TaskUnderstandingService,
+    TaskValidator,
+)
+
+
+def build_context_engine(
+    max_context_units: int = 20,
+) -> DefaultContextEngine:
+    return DefaultContextEngine(
+        candidate_generator=CandidateGenerator(),
+        ranker=DeterministicRanker(),
+        selector=ContextSelector(),
+        depth_selector=ContextDepthSelector(),
+        expander=GraphExpander(),
+        package_builder=ContextPackageBuilder(),
+        enrichment_pipeline=ContextEnrichmentPipeline(
+            enrichers=[
+                FileContextEnricher(),
+                SymbolContextEnricher(),
+                RelationshipContextEnricher(),
+            ],
+        ),
+        compression_pipeline=ContextCompressionPipeline(
+            compressor=DeterministicContextCompressor(),
+            budget_compressor=ContextBudgetCompressor(),
+        ),
+        assembly=ContextAssembler(
+            ContextPriorityOrdering(
+                DeterministicPrioritizer(),
+            ),
+        ),
+        max_context_units=max_context_units,
+    )
+
+
+def build_context_service(
+    max_context_units: int = 20,
+) -> RepositoryContextService:
+    engine = build_context_engine(max_context_units=max_context_units)
+    return RepositoryContextService(
+        engine=engine,
+        task_understanding=TaskUnderstandingService(),
+        task_validator=TaskValidator(),
+        task_grounding=TaskGroundingService(),
+        task_repository_grounding=TaskRepositoryGroundingService(),
+    )

context_forge_local-1.0.0/src/context_forge/application/service.py

@@ -0,0 +1,62 @@
+from context_forge.context.engine import ContextEngine
+from context_forge.context.models import ContextPackage
+from context_forge.context.request import ContextRequest
+from context_forge.models.project import Project
+from context_forge.task import (
+    TaskGroundingService,
+    TaskRepositoryGroundingService,
+    TaskState,
+    TaskUnderstandingService,
+    TaskValidator,
+)
+
+
+class RepositoryContextService:
+    def __init__(
+        self,
+        engine: ContextEngine,
+        task_understanding: TaskUnderstandingService | None = None,
+        task_validator: TaskValidator | None = None,
+        task_grounding: TaskGroundingService | None = None,
+        task_repository_grounding: TaskRepositoryGroundingService | None = None,
+    ) -> None:
+        self.engine = engine
+        self.task_understanding = task_understanding or TaskUnderstandingService()
+        self.task_validator = task_validator or TaskValidator()
+        self.task_grounding = task_grounding or TaskGroundingService()
+        self.task_repository_grounding = (
+            task_repository_grounding or TaskRepositoryGroundingService()
+        )
+
+    def retrieve_context(
+        self,
+        project: Project,
+        task: str,
+    ) -> ContextPackage:
+        if not task.strip():
+            raise ValueError("task must not be empty")
+
+        interpretation = self.task_understanding.understand(task)
+        validation = self.task_validator.validate(interpretation)
+
+        if validation.state != TaskState.CLEAR:
+            raise ValueError(f"task validation failed: {validation.state.value}")
+
+        grounded_task = self.task_grounding.ground(
+            project,
+            interpretation,
+        )
+
+        grounding = self.task_repository_grounding.ground(
+            project,
+            grounded_task,
+        )
+
+        return self.engine.build(
+            ContextRequest(
+                project=project,
+                task=task,
+                interpretation=interpretation,
+                grounding=grounding,
+            )
+        )

context_forge_local-1.0.0/src/context_forge/classifier/__init__.py

@@ -0,0 +1 @@
+

context_forge_local-1.0.0/src/context_forge/classifier/project.py

@@ -0,0 +1,131 @@
+from context_forge.models.enums import FileType
+from context_forge.models.project import Project
+
+LANGUAGE_BY_EXTENSION = {
+    ".py": "Python",
+    ".js": "JavaScript",
+    ".jsx": "JavaScript",
+    ".ts": "TypeScript",
+    ".tsx": "TypeScript",
+    ".java": "Java",
+    ".cpp": "C++",
+    ".cc": "C++",
+    ".hpp": "C++",
+    ".c": "C",
+    ".h": "C",
+    ".go": "Go",
+    ".rs": "Rust",
+    ".rb": "Ruby",
+    ".swift": "Swift",
+    ".kt": "Kotlin",
+    ".php": "PHP",
+}
+
+DOCUMENTATION_EXTENSIONS = {".md", ".rst", ".txt"}
+
+CONFIGURATION_FILES = {
+    "pyproject.toml",
+    "package.json",
+    "package-lock.json",
+    "uv.lock",
+    "Cargo.toml",
+    "go.mod",
+    "requirements.txt",
+    "Makefile",
+    ".gitignore",
+}
+
+FRAMEWORK_INDICATORS = {
+    "fastapi": "FASTAPI",
+    "django": "Django",
+    "flask": "Flask",
+    "react": "React",
+    "next": "Next.js",
+}
+
+
+class ProjectClassifier:
+    def classify(self, project: Project) -> Project:
+        self._classify_files(project)
+        self._detect_languages(project)
+        self._detect_project_types(project)
+        self._detect_package_manager(project)
+        self._detect_frameworks(project)
+
+        return project
+
+    def _detect_project_types(self, project: Project) -> None:
+        file_names = {file.name for file in project.files}
+
+        if "pyproject.toml" in file_names:
+            project.project_type = "python_project"
+        elif "package.json" in file_names:
+            project.project_type = "javascript_project"
+        elif "Cargo.toml" in file_names:
+            project.project_type = "rust_project"
+        elif "go.mod" in file_names:
+            project.project_type = "go_project"
+        elif "pom.xml" in file_names:
+            project.project_type = "java_project"
+        else:
+            project.project_type = "unknown"
+
+    def _classify_files(self, project: Project) -> None:
+        for file in project.files:
+            if file.name in CONFIGURATION_FILES:
+                file.file_type = FileType.CONFIGURATION
+            elif file.extension in DOCUMENTATION_EXTENSIONS:
+                file.file_type = FileType.DOCUMENTATION
+            elif file.path.parts and "tests" in file.path.parts:
+                file.file_type = FileType.TEST
+            elif file.extension in LANGUAGE_BY_EXTENSION:
+                file.file_type = FileType.SOURCE
+            else:
+                file.file_type = FileType.UNKNOWN
+
+    def _detect_languages(self, project: Project):
+        languages = {
+            LANGUAGE_BY_EXTENSION[file.extension]
+            for file in project.files
+            if file.extension in LANGUAGE_BY_EXTENSION
+        }
+
+        project.languages = sorted(languages)
+
+    def _detect_package_manager(self, project: Project) -> None:
+        file_names = {file.name for file in project.files}
+
+        if "uv.lock" in file_names:
+            project.package_manager = "uv"
+        elif "requirements.txt" in file_names:
+            project.package_manager = "pip"
+        elif "package-lock.json" in file_names:
+            project.package_manager = "npm"
+        elif "pnpm-lock.yaml" in file_names:
+            project.package_manager = "pnpm"
+        elif "yarn.lock" in file_names:
+            project.package_manager = "yarn"
+        elif "Cargo.toml" in file_names:
+            project.package_manager = "cargo"
+        elif "go.mod" in file_names:
+            project.package_manager = "go"
+
+    def _detect_frameworks(self, project: Project) -> None:
+        detected: set[str] = set()
+
+        for file in project.files:
+            if file.extension != ".py":
+                continue
+
+            try:
+                content = (project.root_path / file.path).read_text(encoding="utf-8")
+            except (OSError, UnicodeDecodeError):
+                continue
+
+            content_lower = content.lower()
+
+            for indicator, framework in FRAMEWORK_INDICATORS.items():
+                if f"import {indicator}" in content_lower:
+                    detected.add(framework)
+
+        project.frameworks = sorted(detected)

context_forge_local-1.0.0/src/context_forge/comparison/__init__.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from context_forge.comparison.models import (
+    AffectedComponent,
+    AmbiguousMatch,
+    ComparisonState,
+    FileDiff,
+    RelationshipDiff,
+    StateValidationResult,
+    StructuralComparisonResult,
+    SymbolDiff,
+)
+from context_forge.comparison.service import (
+    compare_states,
+    validate_comparison_states,
+)
+
+__all__ = [
+    "AffectedComponent",
+    "AmbiguousMatch",
+    "ComparisonState",
+    "FileDiff",
+    "RelationshipDiff",
+    "StateValidationResult",
+    "StructuralComparisonResult",
+    "SymbolDiff",
+    "compare_states",
+    "validate_comparison_states",
+]