specfact-cli 0.48.2__tar.gz → 0.50.1__tar.gz

{specfact_cli-0.48.2 → specfact_cli-0.50.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfact-cli
-Version: 0.48.2
+Version: 0.50.1
 Summary: AI-bloat defense CLI for Python teams. Run deterministic code review, cleanup forecasts, and spec/contract evidence for AI-assisted and brownfield delivery.
 Project-URL: Homepage, https://github.com/nold-ai/specfact-cli
 Project-URL: Repository, https://github.com/nold-ai/specfact-cli.git

{specfact_cli-0.48.2 → specfact_cli-0.50.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "specfact-cli"
-version = "0.48.2"
+version = "0.50.1"
 description = "AI-bloat defense CLI for Python teams. Run deterministic code review, cleanup forecasts, and spec/contract evidence for AI-assisted and brownfield delivery."
 readme = "README.md"
 requires-python = ">=3.11"

{specfact_cli-0.48.2 → specfact_cli-0.50.1}/src/__init__.py

@@ -3,4 +3,4 @@ SpecFact CLI - AI-bloat defense CLI for Python teams.
 """
 
 # Package version: keep in sync with pyproject.toml, setup.py, src/specfact_cli/__init__.py
-__version__ = "0.48.2"
+__version__ = "0.50.1"

{specfact_cli-0.48.2 → specfact_cli-0.50.1}/src/specfact_cli/__init__.py

@@ -76,6 +76,6 @@ def _install_progressive_disclosure() -> None:
 # keeps missing-command and missing-parameter UX consistent outside the root CLI too.
 _install_progressive_disclosure()
 
-__version__ = "0.48.2"
+__version__ = "0.50.1"
 
 __all__ = ["__version__"]

{specfact_cli-0.48.2 → specfact_cli-0.50.1}/src/specfact_cli/analyzers/code_analyzer.py

@@ -128,10 +128,11 @@ class CodeAnalyzer:
     def _resolve_analyzer_entry_point(repo_path: Path, entry_point: Path | None) -> Path | None:
         if entry_point is None:
             return None
-        resolved = entry_point if entry_point.is_absolute() else (repo_path / entry_point).resolve()
+        resolved_repo_path = repo_path.resolve()
+        resolved = entry_point.resolve() if entry_point.is_absolute() else (resolved_repo_path / entry_point).resolve()
         if not resolved.exists():
             raise ValueError(f"Entry point does not exist: {resolved}")
-        if not str(resolved).startswith(str(repo_path)):
+        if not resolved.is_relative_to(resolved_repo_path):
             raise ValueError(f"Entry point must be within repository: {resolved}")
         return resolved
 

{specfact_cli-0.48.2 → specfact_cli-0.50.1}/src/specfact_cli/models/__init__.py

@@ -37,6 +37,22 @@ from specfact_cli.models.project import (
     SectionLock,
 )
 from specfact_cli.models.protocol import Protocol, Transition
+from specfact_cli.models.requirements import (
+    REQUIREMENTS_INPUT_SCHEMA_VERSION,
+    BusinessRule,
+    RequirementCompletenessFinding,
+    RequirementCompletenessSeverity,
+    RequirementConstraint,
+    RequirementConstraintType,
+    RequirementEvidenceLink,
+    RequirementEvidenceLinkType,
+    RequirementInput,
+    RequirementsInputExtensionPayload,
+    RequirementSourceReference,
+    RequirementSourceType,
+    load_requirements_input_extension,
+    requirements_input_extension_payload,
+)
 from specfact_cli.models.sdd import (
     SDDCoverageThresholds,
     SDDEnforcementBudget,
@@ -49,6 +65,7 @@ from specfact_cli.models.source_tracking import SourceTracking
 
 
 __all__ = [
+    "REQUIREMENTS_INPUT_SCHEMA_VERSION",
     "AdapterType",
     "ArtifactMapping",
     "BridgeConfig",
@@ -57,6 +74,7 @@ __all__ = [
     "BundleManifest",
     "BundleVersions",
     "Business",
+    "BusinessRule",
     "ChangeArchive",
     "ChangeProposal",
     "ChangeTracking",
@@ -84,6 +102,16 @@ __all__ = [
     "Protocol",
     "ProtocolIndex",
     "Release",
+    "RequirementCompletenessFinding",
+    "RequirementCompletenessSeverity",
+    "RequirementConstraint",
+    "RequirementConstraintType",
+    "RequirementEvidenceLink",
+    "RequirementEvidenceLinkType",
+    "RequirementInput",
+    "RequirementSourceReference",
+    "RequirementSourceType",
+    "RequirementsInputExtensionPayload",
     "SDDCoverageThresholds",
     "SDDEnforcementBudget",
     "SDDHow",
@@ -100,4 +128,6 @@ __all__ = [
     "TemplateSection",
     "Transition",
     "ValidationReport",
+    "load_requirements_input_extension",
+    "requirements_input_extension_payload",
 ]

{specfact_cli-0.48.2 → specfact_cli-0.50.1}/src/specfact_cli/models/project.py

@@ -559,7 +559,13 @@ class ProjectBundle(BaseModel):
         if progress_callback:
             progress_callback(current + 1, total_artifacts, "bundle.manifest.yaml")
         manifest_data = load_structured_file(manifest_path)
-        manifest = BundleManifest.model_validate(manifest_data)
+        if not isinstance(manifest_data, dict):
+            raise ValueError("Bundle manifest must be a mapping")
+        manifest_mapping = cast(dict[str, Any], manifest_data)
+        extensions_data = manifest_mapping.get("extensions", {})
+        if not isinstance(extensions_data, dict):
+            raise ValueError("ProjectBundle extensions must be a mapping")
+        manifest = BundleManifest.model_validate(manifest_mapping)
         current += 1
 
         slots = _BundleLoadSlots()
@@ -585,6 +591,7 @@ class ProjectBundle(BaseModel):
             features=slots.features,
             clarifications=slots.clarifications,
             change_tracking=change_tracking,
+            extensions=dict(extensions_data),
         )
 
     @beartype
@@ -663,6 +670,8 @@ class ProjectBundle(BaseModel):
             progress_callback(total_artifacts, total_artifacts, "bundle.manifest.yaml")
         manifest_path = bundle_dir / "bundle.manifest.yaml"
         manifest_data = self.manifest.model_dump(mode="json")
+        if self.extensions:
+            manifest_data["extensions"] = self.extensions
         if num_features > 1000:
             import json
 

specfact_cli-0.50.1/src/specfact_cli/models/requirements.py

@@ -0,0 +1,183 @@
+"""Requirement evidence input models.
+
+These models normalize upstream requirement context for validation evidence.
+They do not make SpecFact the authoring system or source of truth for
+requirements.
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Any, Literal, cast
+
+from beartype import beartype
+from icontract import ensure, require
+from pydantic import BaseModel, ConfigDict, Field
+
+
+REQUIREMENTS_INPUT_SCHEMA_VERSION = "1"
+
+
+class RequirementSourceType(StrEnum):
+    """Supported upstream source reference types."""
+
+    ISSUE = "issue"
+    DOCUMENT = "document"
+    OPENSPEC_CHANGE = "openspec_change"
+    SPECKIT_SPEC = "speckit_spec"
+    FILE = "file"
+    BACKLOG_ITEM = "backlog_item"
+
+
+class RequirementEvidenceLinkType(StrEnum):
+    """Kinds of downstream evidence linked from a requirement input."""
+
+    ARCHITECTURE = "architecture"
+    SPEC = "spec"
+    CODE = "code"
+    TEST = "test"
+    VALIDATION = "validation"
+    REQUIREMENT = "requirement"
+
+
+class RequirementConstraintType(StrEnum):
+    """Supported requirement constraint categories."""
+
+    PERFORMANCE = "performance"
+    SECURITY = "security"
+    INTEGRATION = "integration"
+    COMPLIANCE = "compliance"
+    UX = "ux"
+    OPERATIONAL = "operational"
+
+
+class RequirementCompletenessSeverity(StrEnum):
+    """Advisory completeness finding severity."""
+
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+
+
+@beartype
+class RequirementSourceReference(BaseModel):
+    """Reference to an upstream requirement source."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    source_type: RequirementSourceType = Field(..., description="Type of upstream requirement source")
+    locator: str = Field(..., min_length=1, description="Source locator such as URL, file path, or change ID")
+    title: str | None = Field(default=None, description="Human-readable source title")
+    revision: str | None = Field(default=None, description="Optional source revision, commit, or version")
+
+
+@beartype
+class BusinessRule(BaseModel):
+    """Business rule imported from upstream requirement context."""
+
+    rule_id: str = Field(..., min_length=1, description="Stable business rule identifier")
+    name: str = Field(..., min_length=1, description="Rule name")
+    given: str = Field(..., min_length=1, description="Given clause for validation scenario context")
+    when: str = Field(..., min_length=1, description="When clause for validation scenario context")
+    then: str = Field(..., min_length=1, description="Then clause for validation scenario context")
+    priority: str | None = Field(default=None, description="Optional upstream priority such as MoSCoW")
+
+
+@beartype
+class RequirementConstraint(BaseModel):
+    """Constraint imported from upstream requirement context."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    constraint_id: str = Field(..., min_length=1, description="Stable constraint identifier")
+    constraint_type: RequirementConstraintType = Field(..., description="Constraint category")
+    statement: str = Field(..., min_length=1, description="Constraint statement")
+    validation_criteria: list[str] = Field(default_factory=list, description="Criteria used to validate constraint")
+
+
+@beartype
+class RequirementEvidenceLink(BaseModel):
+    """Link from requirement input to downstream validation evidence."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    link_type: RequirementEvidenceLinkType = Field(..., description="Evidence target category")
+    target: str = Field(..., min_length=1, description="Evidence target locator")
+    relation: str = Field(default="references", min_length=1, description="Relationship to the target")
+
+
+@beartype
+class RequirementCompletenessFinding(BaseModel):
+    """Profile-aware completeness finding stored as advisory evidence."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    profile: str = Field(..., min_length=1, description="Profile that produced this finding")
+    severity: RequirementCompletenessSeverity = Field(..., description="Finding severity")
+    field_path: str = Field(..., min_length=1, description="Requirement field path")
+    message: str = Field(..., min_length=1, description="Human-readable completeness guidance")
+
+
+@beartype
+class RequirementInput(BaseModel):
+    """Normalized requirement context consumed by validation evidence."""
+
+    schema_version: Literal["1"] = Field(..., description="Requirement input schema version")
+    requirement_id: str = Field(..., min_length=1, description="Stable requirement identifier")
+    title: str = Field(..., min_length=1, description="Requirement title")
+    summary: str | None = Field(default=None, description="Optional upstream requirement summary")
+    sources: list[RequirementSourceReference] = Field(
+        ...,
+        min_length=1,
+        description="Upstream requirement source references",
+    )
+    business_rules: list[BusinessRule] = Field(default_factory=list, description="Imported business rules")
+    constraints: list[RequirementConstraint] = Field(default_factory=list, description="Imported constraints")
+    evidence_links: list[RequirementEvidenceLink] = Field(default_factory=list, description="Evidence target links")
+    completeness_findings: list[RequirementCompletenessFinding] = Field(
+        default_factory=list,
+        description="Profile-aware advisory completeness findings",
+    )
+
+
+@beartype
+class RequirementsInputExtensionPayload(BaseModel):
+    """Serializable ProjectBundle extension payload for requirement inputs."""
+
+    schema_version: Literal["1"] = Field(..., description="Requirements extension payload schema version")
+    requirements: list[RequirementInput] = Field(default_factory=list, description="Requirement input records")
+
+
+def _payload_has_schema_version(result: dict[str, Any]) -> bool:
+    return result.get("schema_version") == REQUIREMENTS_INPUT_SCHEMA_VERSION
+
+
+def _payload_has_requirements_list(result: dict[str, Any]) -> bool:
+    return isinstance(result.get("requirements"), list)
+
+
+def _payload_is_valid_extension(payload: dict[str, Any]) -> bool:
+    try:
+        RequirementsInputExtensionPayload.model_validate(payload)
+    except ValueError:
+        return False
+    return True
+
+
+@beartype
+@require(lambda records: all(isinstance(record, RequirementInput) for record in records))
+@ensure(_payload_has_schema_version)
+@ensure(_payload_has_requirements_list)
+def requirements_input_extension_payload(records: list[RequirementInput]) -> dict[str, Any]:
+    """Return a JSON-serializable ProjectBundle extension payload."""
+    payload = RequirementsInputExtensionPayload(schema_version=REQUIREMENTS_INPUT_SCHEMA_VERSION, requirements=records)
+    return cast(dict[str, Any], payload.model_dump(mode="json"))
+
+
+@beartype
+@require(lambda payload: isinstance(payload, dict))
+@require(_payload_is_valid_extension)
+@ensure(lambda result: all(isinstance(record, RequirementInput) for record in result))
+def load_requirements_input_extension(payload: dict[str, Any]) -> list[RequirementInput]:
+    """Load requirement input records from a ProjectBundle extension payload."""
+    return RequirementsInputExtensionPayload.model_validate(payload).requirements

{specfact_cli-0.48.2 → specfact_cli-0.50.1}/src/specfact_cli/registry/module_discovery.py

@@ -91,11 +91,26 @@ def _append_explicit_module_roots(roots: list[tuple[str, Path]]) -> None:
         roots.append(("custom", path))
 
 
+def _should_include_workspace_project_root(options: _DiscoveryRootOptions, legacy: bool) -> bool:
+    only_user_root_is_explicit = (
+        options.user_root is not None
+        and options.builtin_root is None
+        and options.marketplace_root is None
+        and options.custom_root is None
+    )
+    return options.project_base_path is not None or legacy or only_user_root_is_explicit
+
+
 def _discovery_root_list(options: _DiscoveryRootOptions) -> list[tuple[str, Path]]:
     from specfact_cli.registry.module_packages import get_modules_root, get_workspace_modules_root
 
+    legacy = _resolve_include_legacy_roots(options)
     effective_builtin_root = options.builtin_root or get_modules_root()
-    effective_project_root = get_workspace_modules_root(options.project_base_path)
+    effective_project_root = (
+        get_workspace_modules_root(options.project_base_path)
+        if _should_include_workspace_project_root(options, legacy)
+        else None
+    )
     effective_user_root = options.user_root or USER_MODULES_ROOT
     effective_marketplace_root = options.marketplace_root or MARKETPLACE_MODULES_ROOT
     effective_custom_root = options.custom_root or CUSTOM_MODULES_ROOT
@@ -119,7 +134,6 @@ def _discovery_root_list(options: _DiscoveryRootOptions) -> list[tuple[str, Path
         ]
     )
 
-    legacy = _resolve_include_legacy_roots(options)
     if legacy:
         _append_legacy_module_roots(roots)
     return roots

{specfact_cli-0.48.2 → specfact_cli-0.50.1}/src/specfact_cli/registry/module_grouping.py

@@ -8,17 +8,21 @@ from icontract import ensure, require
 from specfact_cli.models.module_package import ModulePackageMetadata
 
 
-VALID_CATEGORIES = frozenset({"core", "project", "backlog", "codebase", "spec", "govern"})
+VALID_CATEGORIES = frozenset({"core", "project", "backlog", "codebase", "spec", "govern", "requirements"})
 CATEGORY_TO_GROUP_COMMAND: dict[str, str] = {
     "project": "project",
     "backlog": "backlog",
     "codebase": "code",
     "spec": "spec",
     "govern": "govern",
+    "requirements": "requirements",
 }
 LEGACY_GROUP_COMMAND_ALIASES: dict[tuple[str, str], str] = {
     ("codebase", "codebase"): "code",
 }
+LEGACY_CATEGORY_ALIASES: dict[tuple[str, str], str] = {
+    ("project", "requirements"): "requirements",
+}
 
 
 class ModuleManifestError(Exception):
@@ -71,6 +75,9 @@ def normalize_legacy_bundle_group_command(meta: ModulePackageMetadata) -> Module
     """Normalize known legacy bundle group values to canonical grouped commands."""
     if meta.category is None or meta.bundle_group_command is None:
         return meta
+    normalized_category = LEGACY_CATEGORY_ALIASES.get((meta.category, meta.bundle_group_command))
+    if normalized_category is not None:
+        meta.category = normalized_category
     normalized = LEGACY_GROUP_COMMAND_ALIASES.get((meta.category, meta.bundle_group_command))
     if normalized is not None:
         meta.bundle_group_command = normalized

specfact_cli-0.50.1/src/specfact_cli/requirements/__init__.py

@@ -0,0 +1,28 @@
+"""Requirements context adapter helpers."""
+
+from specfact_cli.requirements.context import (
+    RequirementContextAdapter,
+    RequirementContextCoverageSummary,
+    RequirementContextDiagnostic,
+    RequirementContextDiagnosticSeverity,
+    RequirementContextImportResult,
+    attach_requirements_to_bundle,
+    inspect_requirement_context_coverage,
+    load_requirements_from_bundle,
+    normalize_requirement_records,
+    validate_requirement_context,
+)
+
+
+__all__ = [
+    "RequirementContextAdapter",
+    "RequirementContextCoverageSummary",
+    "RequirementContextDiagnostic",
+    "RequirementContextDiagnosticSeverity",
+    "RequirementContextImportResult",
+    "attach_requirements_to_bundle",
+    "inspect_requirement_context_coverage",
+    "load_requirements_from_bundle",
+    "normalize_requirement_records",
+    "validate_requirement_context",
+]