opencontext-api 0.1.0__tar.gz

opencontext_api-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 OpenContext Runtime contributors
+
+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.
+

opencontext_api-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: opencontext-api
+Version: 0.1.0
+Summary: FastAPI adapter for OpenContext Runtime
+Author: OpenContext Runtime maintainers
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/CesarMSFelipe/OpenContext-Runtime
+Project-URL: Documentation, https://github.com/CesarMSFelipe/OpenContext-Runtime#readme
+Project-URL: Issues, https://github.com/CesarMSFelipe/OpenContext-Runtime/issues
+Project-URL: Source, https://github.com/CesarMSFelipe/OpenContext-Runtime
+Keywords: ai,llm,context-engineering,fastapi,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Framework :: FastAPI
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Security
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.110
+Requires-Dist: httpx>=0.27
+Requires-Dist: opencontext-core>=0.1.0
+Requires-Dist: opencontext-profiles>=0.1.0
+Dynamic: license-file
+
+# opencontext-api
+
+FastAPI adapter for OpenContext Runtime.
+
+Use this package when a non-Python host needs HTTP endpoints for runtime-first setup and context
+preparation:
+
+- `POST /v1/setup`
+- `POST /v1/context`
+- `GET /v1/traces/{trace_id}`
+
+The API is intentionally thin and delegates context behavior to `opencontext-core`.

opencontext_api-0.1.0/README.md

@@ -0,0 +1,12 @@
+# opencontext-api
+
+FastAPI adapter for OpenContext Runtime.
+
+Use this package when a non-Python host needs HTTP endpoints for runtime-first setup and context
+preparation:
+
+- `POST /v1/setup`
+- `POST /v1/context`
+- `GET /v1/traces/{trace_id}`
+
+The API is intentionally thin and delegates context behavior to `opencontext-core`.

opencontext_api-0.1.0/opencontext_api/__init__.py

@@ -0,0 +1 @@
+"""OpenContext Runtime API package."""

opencontext_api-0.1.0/opencontext_api/main.py

@@ -0,0 +1,314 @@
+"""FastAPI adapter for OpenContext Runtime."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import FastAPI
+
+from opencontext_api.schemas import (
+    AgentContextRequest,
+    ContextPackRequest,
+    ContextPackResponse,
+    IndexRequest,
+    IndexResponse,
+    ManifestResponse,
+    OrchestrateRequest,
+    PreparedContextRequest,
+    PreparedContextResponse,
+    RepoMapResponse,
+    RunRequest,
+    RunResponse,
+    ScaffoldResponse,
+    SetupRequest,
+    SetupResponse,
+    TraceResponse,
+    ValidateRequest,
+)
+from opencontext_core.actions import ActionRequest, ActionType, evaluate_action
+from opencontext_core.doctor.checks import run_doctor
+from opencontext_core.dx.security_reports import scan_project
+from opencontext_core.dx.tokens import build_token_report
+from opencontext_core.project.profiles import TechnologyProfile
+from opencontext_core.runtime import OpenContextRuntime
+from opencontext_core.safety.redaction import SinkGuard
+
+try:
+    from opencontext_profiles import first_party_profiles
+except ModuleNotFoundError:
+
+    def first_party_profiles() -> list[TechnologyProfile]:
+        return []
+
+
+app = FastAPI(title="OpenContext Runtime API", version="0.1.0")
+
+
+def _runtime() -> OpenContextRuntime:
+    return OpenContextRuntime(technology_profiles=first_party_profiles())
+
+
+@app.post("/v1/index", response_model=IndexResponse)
+def index_project(request: IndexRequest) -> IndexResponse:
+    """Index a project root."""
+
+    runtime = _runtime()
+    manifest = runtime.index_project(request.root)
+    return IndexResponse(
+        project_name=manifest.project_name,
+        files=len(manifest.files),
+        symbols=len(manifest.symbols),
+        technology_profiles=manifest.technology_profiles,
+    )
+
+
+@app.post("/v1/setup", response_model=SetupResponse)
+def setup_project(request: SetupRequest) -> SetupResponse:
+    """Create project harness files and persist the project index without CLI commands."""
+
+    runtime = _runtime()
+    result = runtime.setup_project(
+        request.root,
+        write_config=request.write_config,
+        refresh_index=request.refresh_index,
+    )
+    return SetupResponse(**result.model_dump())
+
+
+@app.post("/v1/runs", response_model=RunResponse)
+def run_workflow(request: RunRequest) -> RunResponse:
+    """Run a configured workflow."""
+
+    runtime = _runtime()
+    result = runtime.ask(request.input, request.workflow_name)
+    safe_answer, _ = SinkGuard().redact(result.answer)
+    return RunResponse(
+        answer=safe_answer,
+        trace_id=result.trace_id,
+        token_usage=result.token_usage,
+        selected_context_count=result.selected_context_count,
+    )
+
+
+@app.get("/v1/traces/{trace_id}", response_model=TraceResponse)
+def get_trace(trace_id: str) -> TraceResponse:
+    """Load a persisted trace."""
+
+    runtime = _runtime()
+    trace = runtime.load_trace(trace_id)
+    return TraceResponse(trace=trace.model_dump(mode="json"))
+
+
+@app.get("/v1/project/manifest", response_model=ManifestResponse)
+def get_manifest() -> ManifestResponse:
+    """Load the persisted project manifest."""
+
+    runtime = _runtime()
+    manifest = runtime.load_manifest()
+    return ManifestResponse(manifest=manifest.model_dump(mode="json"))
+
+
+@app.get("/v1/project/repomap", response_model=RepoMapResponse)
+def get_repo_map() -> RepoMapResponse:
+    """Render the compact repository map."""
+
+    runtime = _runtime()
+    safe_repo_map, _ = SinkGuard().redact(runtime.render_repo_map())
+    return RepoMapResponse(repo_map=safe_repo_map)
+
+
+@app.post("/v1/context/pack", response_model=ContextPackResponse)
+def build_context_pack(request: ContextPackRequest) -> ContextPackResponse:
+    """Build a token-aware context pack."""
+
+    runtime = _runtime()
+    pack = runtime.build_context_pack(request.query, request.max_tokens)
+    return ContextPackResponse(pack=pack.model_dump(mode="json"))
+
+
+@app.post("/v1/context", response_model=PreparedContextResponse)
+def prepare_context(request: PreparedContextRequest) -> PreparedContextResponse:
+    """Prepare and persist a compact context bundle for non-CLI callers."""
+
+    runtime = _runtime()
+    prepared = runtime.prepare_context(
+        request.query,
+        root=request.root,
+        max_tokens=request.max_tokens,
+        refresh_index=request.refresh_index,
+    )
+    safe_context, _ = SinkGuard().redact(prepared.context)
+    return PreparedContextResponse(
+        trace_id=prepared.trace_id,
+        context=safe_context,
+        included_sources=prepared.included_sources,
+        omitted_sources=prepared.omitted_sources,
+        token_usage=prepared.token_usage,
+    )
+
+
+@app.get("/v1/security/report")
+def security_report() -> dict[str, object]:
+    return {"status": "scaffold", "result": scan_project().model_dump()}
+
+
+@app.post("/v1/security/scan")
+def security_scan() -> dict[str, object]:
+    return {"status": "scaffold", "result": scan_project().model_dump()}
+
+
+@app.get("/v1/doctor")
+def doctor() -> dict[str, object]:
+    runtime = _runtime()
+    return {"checks": [check.model_dump() for check in run_doctor(runtime.config)]}
+
+
+@app.get("/v1/tokens/report")
+def tokens_report() -> dict[str, object]:
+    return build_token_report(Path(".")).model_dump()
+
+
+@app.post("/v1/orchestrate", response_model=ScaffoldResponse)
+def orchestrate(request: OrchestrateRequest) -> ScaffoldResponse:
+    """Plan a permissioned orchestration run without executing actions."""
+
+    runtime = _runtime()
+    mode = runtime.config.security.mode
+    return ScaffoldResponse(
+        status="scaffold",
+        result={
+            "mode": "orchestrate",
+            "requirements_path": request.requirements_path,
+            "safe_commands": evaluate_action(
+                ActionRequest(action=ActionType.RUN_SAFE_COMMAND),
+                security_mode=mode,
+            ).model_dump(mode="json"),
+            "write_file": evaluate_action(
+                ActionRequest(action=ActionType.WRITE_FILE),
+                security_mode=mode,
+            ).model_dump(mode="json"),
+        },
+    )
+
+
+@app.post("/v1/validate", response_model=ScaffoldResponse)
+def validate(request: ValidateRequest) -> ScaffoldResponse:
+    """Plan safe validation checks without running shell commands."""
+
+    runtime = _runtime()
+    mode = runtime.config.security.mode
+    return ScaffoldResponse(
+        status="scaffold",
+        result={
+            "profile": request.profile,
+            "run_tests": evaluate_action(
+                ActionRequest(action=ActionType.RUN_TEST),
+                security_mode=mode,
+            ).model_dump(mode="json"),
+            "run_linter": evaluate_action(
+                ActionRequest(action=ActionType.RUN_LINTER),
+                security_mode=mode,
+            ).model_dump(mode="json"),
+        },
+    )
+
+
+@app.post("/v1/agent-context", response_model=ScaffoldResponse)
+def agent_context(request: AgentContextRequest) -> ScaffoldResponse:
+    """Return a sanitized generic agent context envelope."""
+
+    runtime = _runtime()
+    prepared = runtime.prepare_context(
+        request.query,
+        root=request.root,
+        max_tokens=request.max_tokens,
+        refresh_index=request.refresh_index,
+    )
+    safe_query, _ = SinkGuard().redact(prepared.query)
+    safe_context, _ = SinkGuard().redact(prepared.context)
+    return ScaffoldResponse(
+        status="ready",
+        result={
+            "target": request.target,
+            "mode": request.mode,
+            "max_tokens": request.max_tokens,
+            "trace_id": prepared.trace_id,
+            "query": safe_query,
+            "context": safe_context,
+            "included_sources": prepared.included_sources,
+            "omitted_sources": prepared.omitted_sources,
+            "token_usage": prepared.token_usage,
+            "raw_secrets_included": False,
+        },
+    )
+
+
+@app.post("/v1/refactor/sdd", response_model=ScaffoldResponse)
+def sdd_flow(request: PreparedContextRequest) -> ScaffoldResponse:
+    """Specification-Driven Development (SDD) context engineering flow.
+
+    Unified workflow for context preparation across all technology stacks.
+    Implements the SDD flow: explore → propose → test → verify → review.
+
+    This endpoint is technology-agnostic and works with any framework,
+    language, or architecture pattern. It integrates with OpenContext's
+    agent-agnostic workflow engine to provide consistent context preparation
+    regardless of the underlying technology.
+    """
+
+    runtime = _runtime()
+
+    # Phase 1: Explore - retrieve and rank candidates
+    prepared = runtime.prepare_context(
+        request.query,
+        root=request.root,
+        max_tokens=request.max_tokens,
+        refresh_index=request.refresh_index,
+    )
+
+    safe_query, _ = SinkGuard().redact(prepared.query)
+    safe_context, _ = SinkGuard().redact(prepared.context)
+
+    # Phase 2: Test - validate context pack safety
+    from opencontext_core.safety.firewall import ContextFirewall
+
+    firewall = ContextFirewall(runtime.config)
+    test_decision = firewall.check_context_export(
+        prepared.included_sources,
+        sink="sdd_test",
+    )
+
+    # Phase 3: Verify - security scan
+    from opencontext_core.dx.security_reports import scan_project
+
+    scan = scan_project(request.root)
+
+    # Phase 4: Review - check for high-risk patterns
+    manifest = runtime.load_manifest()
+    high_risk_count = sum(
+        1
+        for f in manifest.files
+        if any(s in f.path.lower() for s in ["secret", "key", "credential", "token", "password"])
+    )
+
+    return ScaffoldResponse(
+        status="completed",
+        result={
+            "mode": "sdd",
+            "trace_id": prepared.trace_id,
+            "query": safe_query,
+            "context": safe_context,
+            "included_sources": prepared.included_sources,
+            "omitted_sources": prepared.omitted_sources,
+            "token_usage": prepared.token_usage,
+            "raw_secrets_included": False,
+            "safety": {
+                "test_allowed": test_decision.allowed,
+                "test_reason": test_decision.reason,
+                "security_scan_severity": scan.severity.value,
+                "security_findings": len(scan.findings),
+                "high_risk_files": high_risk_count,
+                "review_status": "approved" if high_risk_count == 0 else "requires_review",
+            },
+        },
+    )

opencontext_api-0.1.0/opencontext_api/schemas.py

@@ -0,0 +1,184 @@
+"""FastAPI schemas for the OpenContext Runtime adapter."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class IndexRequest(BaseModel):
+    """Request body for project indexing."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    root: str = Field(default=".", description="Project root to index.")
+
+
+class IndexResponse(BaseModel):
+    """Response body for project indexing."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    project_name: str = Field(description="Indexed project name.")
+    files: int = Field(ge=0, description="Number of indexed files.")
+    symbols: int = Field(ge=0, description="Number of extracted symbols.")
+    technology_profiles: list[str] = Field(description="Detected technology profiles.")
+
+
+class SetupRequest(BaseModel):
+    """Request body for non-CLI project setup."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    root: str = Field(default=".", description="Project root to prepare.")
+    write_config: bool = Field(
+        default=True,
+        description="Whether to create opencontext.yaml when it is missing.",
+    )
+    refresh_index: bool = Field(
+        default=True,
+        description="Whether to rebuild and persist the project manifest.",
+    )
+
+
+class SetupResponse(BaseModel):
+    """Response body for non-CLI project setup."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    root: str = Field(description="Prepared project root.")
+    config_path: str = Field(description="OpenContext YAML configuration path.")
+    workspace_path: str = Field(description="Project-local .opencontext workspace path.")
+    manifest_path: str = Field(description="Persisted project manifest path.")
+    files: int = Field(ge=0, description="Indexed file count.")
+    symbols: int = Field(ge=0, description="Indexed symbol count.")
+    technology_profiles: list[str] = Field(description="Detected technology profiles.")
+
+
+class RunRequest(BaseModel):
+    """Request body for workflow execution."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    input: str = Field(description="User request.")
+    workflow_name: str = Field(default="code_assistant", description="Workflow name.")
+
+
+class RunResponse(BaseModel):
+    """Response body for workflow execution."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    answer: str = Field(description="Generated answer.")
+    trace_id: str = Field(description="Persisted trace id.")
+    token_usage: dict[str, int] = Field(description="Token usage summary.")
+    selected_context_count: int = Field(ge=0, description="Selected context item count.")
+
+
+class TraceResponse(BaseModel):
+    """Response body for trace lookup."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    trace: dict[str, Any] = Field(description="Serialized runtime trace.")
+
+
+class ManifestResponse(BaseModel):
+    """Response body for project manifest lookup."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    manifest: dict[str, Any] = Field(description="Serialized project manifest.")
+
+
+class RepoMapResponse(BaseModel):
+    """Response body for repository map lookup."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    repo_map: str = Field(description="Rendered compact repo map.")
+
+
+class ContextPackRequest(BaseModel):
+    """Request body for context pack generation."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    query: str = Field(description="Retrieval query.")
+    max_tokens: int | None = Field(default=None, gt=0, description="Optional pack budget.")
+
+
+class ContextPackResponse(BaseModel):
+    """Response body for context pack generation."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    pack: dict[str, Any] = Field(description="Serialized context pack result.")
+
+
+class PreparedContextRequest(BaseModel):
+    """Request body for simple non-CLI context preparation."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    query: str = Field(description="Task or question to prepare context for.")
+    root: str = Field(default=".", description="Project root to index when needed.")
+    max_tokens: int | None = Field(default=None, gt=0, description="Optional context budget.")
+    refresh_index: bool = Field(
+        default=False,
+        description="Whether to rebuild the persisted project manifest before retrieval.",
+    )
+
+
+class PreparedContextResponse(BaseModel):
+    """Response body for persisted non-CLI context preparation."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    trace_id: str = Field(description="Persisted trace id for this context bundle.")
+    context: str = Field(description="Compact redacted context text.")
+    included_sources: list[str] = Field(description="Sources included in the context.")
+    omitted_sources: list[str] = Field(description="Sources omitted from the context.")
+    token_usage: dict[str, int] = Field(description="Context and prompt token accounting.")
+
+
+class OrchestrateRequest(BaseModel):
+    """Request body for orchestration planning."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    requirements_path: str = Field(description="Path to requirements used for planning.")
+
+
+class ValidateRequest(BaseModel):
+    """Request body for safe validation planning."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    profile: str = Field(default="generic", description="Validation profile.")
+
+
+class AgentContextRequest(BaseModel):
+    """Request body for agent-context export planning."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    query: str = Field(description="Task or question for the target agent.")
+    root: str = Field(default=".", description="Project root to index when needed.")
+    target: str = Field(default="generic", description="Target agent context format.")
+    mode: str = Field(default="plan", description="Context mode.")
+    max_tokens: int = Field(default=10000, gt=0, description="Maximum context budget.")
+    refresh_index: bool = Field(
+        default=False,
+        description="Whether to rebuild the persisted project manifest before retrieval.",
+    )
+
+
+class ScaffoldResponse(BaseModel):
+    """Generic response for scaffolded v0.1 endpoints."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    status: str = Field(description="Endpoint implementation status.")
+    result: dict[str, Any] = Field(description="Structured scaffold result.")

opencontext_api-0.1.0/opencontext_api.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: opencontext-api
+Version: 0.1.0
+Summary: FastAPI adapter for OpenContext Runtime
+Author: OpenContext Runtime maintainers
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/CesarMSFelipe/OpenContext-Runtime
+Project-URL: Documentation, https://github.com/CesarMSFelipe/OpenContext-Runtime#readme
+Project-URL: Issues, https://github.com/CesarMSFelipe/OpenContext-Runtime/issues
+Project-URL: Source, https://github.com/CesarMSFelipe/OpenContext-Runtime
+Keywords: ai,llm,context-engineering,fastapi,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Framework :: FastAPI
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Security
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.110
+Requires-Dist: httpx>=0.27
+Requires-Dist: opencontext-core>=0.1.0
+Requires-Dist: opencontext-profiles>=0.1.0
+Dynamic: license-file
+
+# opencontext-api
+
+FastAPI adapter for OpenContext Runtime.
+
+Use this package when a non-Python host needs HTTP endpoints for runtime-first setup and context
+preparation:
+
+- `POST /v1/setup`
+- `POST /v1/context`
+- `GET /v1/traces/{trace_id}`
+
+The API is intentionally thin and delegates context behavior to `opencontext-core`.

opencontext_api-0.1.0/opencontext_api.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+opencontext_api/__init__.py
+opencontext_api/main.py
+opencontext_api/schemas.py
+opencontext_api.egg-info/PKG-INFO
+opencontext_api.egg-info/SOURCES.txt
+opencontext_api.egg-info/dependency_links.txt
+opencontext_api.egg-info/requires.txt
+opencontext_api.egg-info/top_level.txt

opencontext_api-0.1.0/opencontext_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

opencontext_api-0.1.0/opencontext_api.egg-info/requires.txt

@@ -0,0 +1,4 @@
+fastapi>=0.110
+httpx>=0.27
+opencontext-core>=0.1.0
+opencontext-profiles>=0.1.0

opencontext_api-0.1.0/opencontext_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+opencontext_api

opencontext_api-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "opencontext-api"
+version = "0.1.0"
+description = "FastAPI adapter for OpenContext Runtime"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "OpenContext Runtime maintainers" }]
+keywords = ["ai", "llm", "context-engineering", "fastapi", "security"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Framework :: FastAPI",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+  "Topic :: Security",
+]
+dependencies = [
+  "fastapi>=0.110",
+  "httpx>=0.27",
+  "opencontext-core>=0.1.0",
+  "opencontext-profiles>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/CesarMSFelipe/OpenContext-Runtime"
+Documentation = "https://github.com/CesarMSFelipe/OpenContext-Runtime#readme"
+Issues = "https://github.com/CesarMSFelipe/OpenContext-Runtime/issues"
+Source = "https://github.com/CesarMSFelipe/OpenContext-Runtime"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["opencontext_api*"]

opencontext_api-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+