fortresscodeai 0.1.0__tar.gz

fortresscodeai-0.1.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 FortressCodeAI
+
+All rights reserved.
+
+Permission is granted to approved design partners and contributors, under a valid non-disclosure agreement (NDA), to access, review, and test the source code in this repository solely for evaluation, collaboration, and prototyping purposes.
+
+This license strictly prohibits:
+- Commercial use or deployment of the code or any derivative works
+- Redistribution, sublicensing, or publication of the code or any part thereof
+- Modification or reuse of the code outside the scope of the NDA
+- Use of FortressCodeAI branding, trademarks, or likeness without written consent
+
+All intellectual property, including but not limited to source code, architecture, design patterns, and documentation, remains the exclusive property of FortressCodeAI.
+
+This software is provided "as is", without warranty of any kind, express or implied, including but not limited to warranties of merchantability, fitness for a particular purpose, or noninfringement.
+
+Violation of these terms may result in legal action.
+
+For licensing, partnership, or commercial use inquiries, contact: fortresscodeai@outlook.com

fortresscodeai-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: fortresscodeai
+Version: 0.1.0
+Summary: FortressCodeAI Platform
+Project-URL: Homepage, https://fortresscode.ai
+Project-URL: Documentation, https://docs.fortresscode.ai
+Project-URL: Source, https://github.com/your-org/fortresscodeai
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn>=0.29
+Requires-Dist: pydantic>=2.6
+Requires-Dist: click>=8.1
+Requires-Dist: requests<3.0,>=2.31
+Requires-Dist: PyYAML<7.0,>=6.0
+Requires-Dist: jinja2<4.0,>=3.1
+Dynamic: license-file
+
+# FortressCodeAI
+
+## Governance‑First AI Orchestration Platform
+
+FortressCodeAI is a governance‑driven AI automation platform designed for organizations that require transparency, auditability, human oversight, and policy‑locked workflows. It provides a unified orchestration engine, a multi‑tab executive dashboard, a developer console, a plugin system, and a governance‑first workflow runtime with HITL (Human‑In‑The‑Loop) controls.
+
+The platform demonstrates responsible automation for executives, union leadership, and technical teams—showing that AI systems can be safe, explainable, and aligned with organizational values.
+
+---
+
+## Core Capabilities
+
+### AI Workflow Orchestration
+
+- Multi‑step workflows with validation, execution, and async processing  
+- Policy‑locked execution with automatic blocking for unsafe actions  
+- HITL checkpoints for sensitive or high‑risk steps  
+- Full audit trail for every workflow, step, and decision  
+- Security event logging for anomalous or policy‑violating behavior  
+
+### Governance & Compliance
+
+- Workflow‑level and step‑level policy validation  
+- Explainability coverage and traceability  
+- Union‑aligned safeguards (role displacement detection, sensitivity flags)  
+- RBAC‑aligned security events and access controls  
+
+### Human‑In‑The‑Loop (HITL)
+
+- Approval queue for sensitive steps  
+- Operator load tracking  
+- Escalation workflows  
+- Full auditability of human decisions  
+
+### Executive Superdashboard
+
+A multi‑tab, governance‑first dashboard including:
+
+- System Overview  
+- Governance & Compliance  
+- Human Oversight (HITL)  
+- Security & Access  
+- Workforce Impact  
+- Activity Timeline  
+
+### Developer Console
+
+- Storage inspector  
+- Workflow definitions  
+- Policy editor  
+- Agent sandbox  
+- Live logs and events  
+
+### Plugin System
+
+- Drop‑in Python modules  
+- Auto‑loaded at startup  
+- Can expose new API routes, workflows, or tools  
+
+---
+
+## Installation
+
+FortressCodeAI installs a global CLI named `fortress`.
+
+### Install from PyPI
+
+```bash
+pip install fortresscodeai

fortresscodeai-0.1.0/README.md

@@ -0,0 +1,69 @@
+# FortressCodeAI
+
+## Governance‑First AI Orchestration Platform
+
+FortressCodeAI is a governance‑driven AI automation platform designed for organizations that require transparency, auditability, human oversight, and policy‑locked workflows. It provides a unified orchestration engine, a multi‑tab executive dashboard, a developer console, a plugin system, and a governance‑first workflow runtime with HITL (Human‑In‑The‑Loop) controls.
+
+The platform demonstrates responsible automation for executives, union leadership, and technical teams—showing that AI systems can be safe, explainable, and aligned with organizational values.
+
+---
+
+## Core Capabilities
+
+### AI Workflow Orchestration
+
+- Multi‑step workflows with validation, execution, and async processing  
+- Policy‑locked execution with automatic blocking for unsafe actions  
+- HITL checkpoints for sensitive or high‑risk steps  
+- Full audit trail for every workflow, step, and decision  
+- Security event logging for anomalous or policy‑violating behavior  
+
+### Governance & Compliance
+
+- Workflow‑level and step‑level policy validation  
+- Explainability coverage and traceability  
+- Union‑aligned safeguards (role displacement detection, sensitivity flags)  
+- RBAC‑aligned security events and access controls  
+
+### Human‑In‑The‑Loop (HITL)
+
+- Approval queue for sensitive steps  
+- Operator load tracking  
+- Escalation workflows  
+- Full auditability of human decisions  
+
+### Executive Superdashboard
+
+A multi‑tab, governance‑first dashboard including:
+
+- System Overview  
+- Governance & Compliance  
+- Human Oversight (HITL)  
+- Security & Access  
+- Workforce Impact  
+- Activity Timeline  
+
+### Developer Console
+
+- Storage inspector  
+- Workflow definitions  
+- Policy editor  
+- Agent sandbox  
+- Live logs and events  
+
+### Plugin System
+
+- Drop‑in Python modules  
+- Auto‑loaded at startup  
+- Can expose new API routes, workflows, or tools  
+
+---
+
+## Installation
+
+FortressCodeAI installs a global CLI named `fortress`.
+
+### Install from PyPI
+
+```bash
+pip install fortresscodeai

fortresscodeai-0.1.0/backend/Modules/autobuilder_orchestration/backend/models/autobuilder.py

@@ -0,0 +1,28 @@
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel
+from datetime import datetime
+from enum import Enum
+
+
+class BuildStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    FAILED = "failed"
+    COMPLETED = "completed"
+    BLOCKED_HITL = "blocked_hitl"
+
+
+class BuildRequest(BaseModel):
+    id: str
+    created_at: datetime
+    requested_by: str
+    blueprint: Dict[str, Any]
+    correlation_id: str
+
+
+class BuildArtifact(BaseModel):
+    id: str
+    build_id: str
+    created_at: datetime
+    artifact_type: str  # e.g. "agent", "workflow", "test_suite"
+    content: Dict[str, Any]

fortresscodeai-0.1.0/backend/Modules/autobuilder_orchestration/backend/services/autobuilder_service.py

@@ -0,0 +1,76 @@
+from typing import Dict, Any
+from datetime import datetime
+import uuid
+
+from backend.Modules.autobuilder_orchestration.backend.models.autobuilder import BuildRequest, BuildArtifact, BuildStatus
+from backend.models.policy import PolicyViolation
+from backend.services.policy.policy_engine import PolicyEngine
+from backend.services.hitl_service import HITLService
+from backend.Modules.audit_logging_engine import AuditService
+
+
+
+class AutobuilderService:
+    def __init__(self, store, policy_engine: PolicyEngine, hitl: HITLService, audit: AuditService):
+        self.store = store
+        self.policy_engine = policy_engine
+        self.hitl = hitl
+        self.audit = audit
+
+    def submit_build(self, requested_by: str, blueprint: Dict[str, Any]) -> BuildRequest:
+        correlation_id = str(uuid.uuid4())
+        build_request = BuildRequest(
+            id=str(uuid.uuid4()),
+            created_at=datetime.utcnow(),
+            requested_by=requested_by,
+            blueprint=blueprint,
+            correlation_id=correlation_id,
+        )
+        self.store.save_build_request(build_request)
+        self.audit.log_event(
+            actor=requested_by,
+            action="build_submitted",
+            resource=f"build:{build_request.id}",
+            details={"blueprint": blueprint},
+            correlation_id=correlation_id,
+        )
+        return build_request
+
+    def run_build(self, build_request: BuildRequest) -> BuildArtifact:
+        context = {"blueprint": build_request.blueprint, "requested_by": build_request.requested_by}
+        violations = self.policy_engine.evaluate(context)
+
+        if any(v.severity in ("high", "critical") for v in violations):
+            # create HITL task and block
+            self.hitl.create_review_task(
+                correlation_id=build_request.correlation_id,
+                actor="autobuilder",
+                payload={"build_request_id": build_request.id, "violations": [v.dict() for v in violations]},
+            )
+            self.audit.log_event(
+                actor="autobuilder",
+                action="build_blocked_hitl",
+                resource=f"build:{build_request.id}",
+                details={"violations": [v.dict() for v in violations]},
+                correlation_id=build_request.correlation_id,
+            )
+            # you might persist status as BLOCKED_HITL here
+            raise RuntimeError("Build blocked pending human review")
+
+        # TODO: actual generation logic
+        artifact = BuildArtifact(
+            id=str(uuid.uuid4()),
+            build_id=build_request.id,
+            created_at=datetime.utcnow(),
+            artifact_type="agent",
+            content={"generated": True, "blueprint": build_request.blueprint},
+        )
+        self.store.save_build_artifact(artifact)
+        self.audit.log_event(
+            actor="autobuilder",
+            action="build_completed",
+            resource=f"build:{build_request.id}",
+            details={"artifact_id": artifact.id},
+            correlation_id=build_request.correlation_id,
+        )
+        return artifact

fortresscodeai-0.1.0/backend/Modules/dispute_resolution_system/backend/models/audit.py

@@ -0,0 +1,21 @@
+from typing import Any, Dict, Optional, List
+from pydantic import BaseModel
+from datetime import datetime
+
+
+class AuditLogEntry(BaseModel):
+    id: str
+    timestamp: datetime
+    actor: str
+    action: str
+    resource: Optional[str] = None
+    details: Dict[str, Any]
+    correlation_id: Optional[str] = None
+    tags: List[str] = []
+
+
+class AuditBundle(BaseModel):
+    bundle_id: str
+    created_at: datetime
+    correlation_id: str
+    entries: List[AuditLogEntry]

fortresscodeai-0.1.0/backend/Modules/dispute_resolution_system/backend/pipelines/governance_pipeline.py

@@ -0,0 +1,32 @@
+from typing import Dict, Any
+
+from backend.services.audit_service import AuditService
+from backend.services.policy.policy_engine import PolicyEngine
+from backend.services.hitl_service import HITLService
+from backend.Modules.dispute_resolution_system.backend.services.disputes_service import DisputesService
+
+
+class GovernancePipeline:
+    def __init__(
+        self,
+        audit: AuditService,
+        policy: PolicyEngine,
+        hitl: HITLService,
+        disputes: DisputesService,
+    ):
+        self.audit = audit
+        self.policy = policy
+        self.hitl = hitl
+        self.disputes = disputes
+
+    def process_action(self, actor: str, action: str, context: Dict[str, Any], correlation_id: str):
+        self.audit.log_event(
+            actor=actor,
+            action=action,
+            details=context,
+            correlation_id=correlation_id,
+        )
+
+        violations = self.policy.evaluate(context)
+        # you can route violations to HITL, autobuilder, etc. here
+        return violations

fortresscodeai-0.1.0/backend/Modules/dispute_resolution_system/backend/services/audit_service.py

@@ -0,0 +1,46 @@
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import uuid
+
+from backend.models.audit import AuditLogEntry, AuditBundle
+
+
+class AuditService:
+    def __init__(self, store):
+        self.store = store  # e.g. DB adapter, message bus, etc.
+
+    def log_event(
+        self,
+        actor: str,
+        action: str,
+        resource: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+    ) -> AuditLogEntry:
+        entry = AuditLogEntry(
+            id=str(uuid.uuid4()),
+            timestamp=datetime.utcnow(),
+            actor=actor,
+            action=action,
+            resource=resource,
+            details=details or {},
+            correlation_id=correlation_id,
+            tags=tags or [],
+        )
+        self.store.save_audit_entry(entry)
+        return entry
+
+    def get_entries_by_correlation(self, correlation_id: str) -> List[AuditLogEntry]:
+        return self.store.get_entries_by_correlation(correlation_id)
+
+    def create_bundle(self, correlation_id: str) -> AuditBundle:
+        entries = self.get_entries_by_correlation(correlation_id)
+        bundle = AuditBundle(
+            bundle_id=str(uuid.uuid4()),
+            created_at=datetime.utcnow(),
+            correlation_id=correlation_id,
+            entries=entries,
+        )
+        self.store.save_audit_bundle(bundle)
+        return bundle

fortresscodeai-0.1.0/backend/Modules/dispute_resolution_system/backend/services/disputes_service.py

@@ -0,0 +1,65 @@
+from typing import Optional
+from datetime import datetime
+import uuid
+
+from backend.models.disputes import DisputeCase, DisputeStatus
+from backend.Modules.audit_logging_engine import AuditService
+
+
+class DisputesService:
+    def __init__(self, store, audit: AuditService):
+        self.store = store
+        self.audit = audit
+
+    def open_dispute(
+        self,
+        opened_by: str,
+        correlation_id: str,
+        subject: str,
+        description: str,
+    ) -> DisputeCase:
+        case = DisputeCase(
+            id=str(uuid.uuid4()),
+            created_at=datetime.utcnow(),
+            opened_by=opened_by,
+            correlation_id=correlation_id,
+            subject=subject,
+            description=description,
+        )
+        self.store.save_dispute_case(case)
+        self.audit.log_event(
+            actor=opened_by,
+            action="dispute_opened",
+            resource=f"dispute:{case.id}",
+            details={"subject": subject},
+            correlation_id=correlation_id,
+        )
+        return case
+
+    def attach_evidence_bundle(self, case_id: str, bundle_id: str) -> DisputeCase:
+        case = self.store.get_dispute_case(case_id)
+        case.evidence_bundle_id = bundle_id
+        self.store.update_dispute_case(case)
+        self.audit.log_event(
+            actor="system",
+            action="dispute_evidence_attached",
+            resource=f"dispute:{case.id}",
+            details={"bundle_id": bundle_id},
+            correlation_id=case.correlation_id,
+        )
+        return case
+
+    def resolve_dispute(self, case_id: str, resolution: str) -> DisputeCase:
+        case = self.store.get_dispute_case(case_id)
+        case.status = DisputeStatus.RESOLVED
+        case.resolution = resolution
+        case.resolved_at = datetime.utcnow()
+        self.store.update_dispute_case(case)
+        self.audit.log_event(
+            actor="system",
+            action="dispute_resolved",
+            resource=f"dispute:{case.id}",
+            details={"resolution": resolution},
+            correlation_id=case.correlation_id,
+        )
+        return case