code-factory-2-forge 0.9.0__tar.gz → 0.9.2__tar.gz

{code_factory_2_forge-0.9.0/code_factory_2_forge.egg-info → code_factory_2_forge-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-factory-2-forge
-Version: 0.9.0
+Version: 0.9.2
 Summary: ForgeLine — the autonomous outer loop for AI software factories. A CLI-backed state machine that drives intent -> spec -> plan -> code -> adversarial review -> ship, orchestrating SpecLine (spec governance) and Harness Software Factory (compiled decisions), with self-improving skills and architecture-as-a-CI-gate.
 License-Expression: MIT OR Apache-2.0
 Project-URL: Homepage, https://github.com/zrk222/code-factory-2-forge
@@ -77,7 +77,7 @@ forge init
 forge agent claude         # wire your agent (see full list below)
 forge status <feature>     # the state machine names the ONE next action
 forge optimize-pr <feature> # bounded PR hardening loop plan
-pytest -q                  # 29 tests
+pytest -q                  # full ForgeLine suite
 ```
 
 ## PR hardening loop
@@ -123,6 +123,22 @@ as the CI gate: `check_erosion()` detects signature drift (`E_SIG_DRIFT`),
 illegal dependencies (`E_ILLEGAL_DEP`), and invariant violations
 (`E_INVARIANT`) — structural erosion caught before merge.
 
+**Scaffolding is fail-closed.** `forge architect` will not overwrite an
+existing module. Start with a plan:
+
+```bash
+forge architect <feature> <ssat> --dry-run --root .
+```
+
+The JSON report separates `created`, `skipped`, `conflicts`, and `overwritten`
+files and includes before/after SHA-256 values. Existing targets are reported as
+conflicts and leave both the files and feature state unchanged. An intentional
+replacement requires `--force`; ForgeLine first writes timestamped backups under
+`.forge/scaffold-backups/`, validates every generated file, and restores every
+modified target if any replacement fails. Python, TypeScript, and TSX scaffolds
+use extension-specific generators and structure checks; unsupported extensions
+are rejected rather than receiving Python syntax.
+
 **The grumpy adversary.** A review agent that *assumes your code is broken and
 insecure* and makes the generator prove otherwise. Executable heuristics catch
 eval/exec/shell-injection/hard-coded-secrets/bare-excepts, and it refuses to
@@ -157,7 +173,9 @@ forge agent claude|codex            wire the entry-point skill
 forge status <feature>              current state + the ONE next action
 forge expand <feature>              draft use cases (→ human gate)
 forge gate architected <feature>    record explicit architecture approval
-forge architect <feature> <ssat>    generate scaffold from architecture-as-code
+forge architect <feature> <ssat> --dry-run  show create/conflict/overwrite plan without writes
+forge architect <feature> <ssat>            generate new files; existing files fail closed
+forge architect <feature> <ssat> --force    back up then intentionally replace existing targets
 forge fill <feature> <ssat>         prove bodies are implemented; enter FILLED
 forge review <feature> <ssat>       judge + grumpy adversary + arch erosion (refine loop)
 forge arch-gate <feature> <ssat>    architecture CI gate

{code_factory_2_forge-0.9.0 → code_factory_2_forge-0.9.2}/README.md

@@ -59,7 +59,7 @@ forge init
 forge agent claude         # wire your agent (see full list below)
 forge status <feature>     # the state machine names the ONE next action
 forge optimize-pr <feature> # bounded PR hardening loop plan
-pytest -q                  # 29 tests
+pytest -q                  # full ForgeLine suite
 ```
 
 ## PR hardening loop
@@ -105,6 +105,22 @@ as the CI gate: `check_erosion()` detects signature drift (`E_SIG_DRIFT`),
 illegal dependencies (`E_ILLEGAL_DEP`), and invariant violations
 (`E_INVARIANT`) — structural erosion caught before merge.
 
+**Scaffolding is fail-closed.** `forge architect` will not overwrite an
+existing module. Start with a plan:
+
+```bash
+forge architect <feature> <ssat> --dry-run --root .
+```
+
+The JSON report separates `created`, `skipped`, `conflicts`, and `overwritten`
+files and includes before/after SHA-256 values. Existing targets are reported as
+conflicts and leave both the files and feature state unchanged. An intentional
+replacement requires `--force`; ForgeLine first writes timestamped backups under
+`.forge/scaffold-backups/`, validates every generated file, and restores every
+modified target if any replacement fails. Python, TypeScript, and TSX scaffolds
+use extension-specific generators and structure checks; unsupported extensions
+are rejected rather than receiving Python syntax.
+
 **The grumpy adversary.** A review agent that *assumes your code is broken and
 insecure* and makes the generator prove otherwise. Executable heuristics catch
 eval/exec/shell-injection/hard-coded-secrets/bare-excepts, and it refuses to
@@ -139,7 +155,9 @@ forge agent claude|codex            wire the entry-point skill
 forge status <feature>              current state + the ONE next action
 forge expand <feature>              draft use cases (→ human gate)
 forge gate architected <feature>    record explicit architecture approval
-forge architect <feature> <ssat>    generate scaffold from architecture-as-code
+forge architect <feature> <ssat> --dry-run  show create/conflict/overwrite plan without writes
+forge architect <feature> <ssat>            generate new files; existing files fail closed
+forge architect <feature> <ssat> --force    back up then intentionally replace existing targets
 forge fill <feature> <ssat>         prove bodies are implemented; enter FILLED
 forge review <feature> <ssat>       judge + grumpy adversary + arch erosion (refine loop)
 forge arch-gate <feature> <ssat>    architecture CI gate

{code_factory_2_forge-0.9.0 → code_factory_2_forge-0.9.2/code_factory_2_forge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-factory-2-forge
-Version: 0.9.0
+Version: 0.9.2
 Summary: ForgeLine — the autonomous outer loop for AI software factories. A CLI-backed state machine that drives intent -> spec -> plan -> code -> adversarial review -> ship, orchestrating SpecLine (spec governance) and Harness Software Factory (compiled decisions), with self-improving skills and architecture-as-a-CI-gate.
 License-Expression: MIT OR Apache-2.0
 Project-URL: Homepage, https://github.com/zrk222/code-factory-2-forge
@@ -77,7 +77,7 @@ forge init
 forge agent claude         # wire your agent (see full list below)
 forge status <feature>     # the state machine names the ONE next action
 forge optimize-pr <feature> # bounded PR hardening loop plan
-pytest -q                  # 29 tests
+pytest -q                  # full ForgeLine suite
 ```
 
 ## PR hardening loop
@@ -123,6 +123,22 @@ as the CI gate: `check_erosion()` detects signature drift (`E_SIG_DRIFT`),
 illegal dependencies (`E_ILLEGAL_DEP`), and invariant violations
 (`E_INVARIANT`) — structural erosion caught before merge.
 
+**Scaffolding is fail-closed.** `forge architect` will not overwrite an
+existing module. Start with a plan:
+
+```bash
+forge architect <feature> <ssat> --dry-run --root .
+```
+
+The JSON report separates `created`, `skipped`, `conflicts`, and `overwritten`
+files and includes before/after SHA-256 values. Existing targets are reported as
+conflicts and leave both the files and feature state unchanged. An intentional
+replacement requires `--force`; ForgeLine first writes timestamped backups under
+`.forge/scaffold-backups/`, validates every generated file, and restores every
+modified target if any replacement fails. Python, TypeScript, and TSX scaffolds
+use extension-specific generators and structure checks; unsupported extensions
+are rejected rather than receiving Python syntax.
+
 **The grumpy adversary.** A review agent that *assumes your code is broken and
 insecure* and makes the generator prove otherwise. Executable heuristics catch
 eval/exec/shell-injection/hard-coded-secrets/bare-excepts, and it refuses to
@@ -157,7 +173,9 @@ forge agent claude|codex            wire the entry-point skill
 forge status <feature>              current state + the ONE next action
 forge expand <feature>              draft use cases (→ human gate)
 forge gate architected <feature>    record explicit architecture approval
-forge architect <feature> <ssat>    generate scaffold from architecture-as-code
+forge architect <feature> <ssat> --dry-run  show create/conflict/overwrite plan without writes
+forge architect <feature> <ssat>            generate new files; existing files fail closed
+forge architect <feature> <ssat> --force    back up then intentionally replace existing targets
 forge fill <feature> <ssat>         prove bodies are implemented; enter FILLED
 forge review <feature> <ssat>       judge + grumpy adversary + arch erosion (refine loop)
 forge arch-gate <feature> <ssat>    architecture CI gate

{code_factory_2_forge-0.9.0 → code_factory_2_forge-0.9.2}/forgeline/__init__.py

@@ -11,4 +11,4 @@ hard CI gate, and learning from every run via an evolving skill memory.
                          └──────── refine loop ─────────┘
                                    skill memory learns each pass
 """
-__version__ = "0.7.0"
+__version__ = "0.9.1"

{code_factory_2_forge-0.9.0 → code_factory_2_forge-0.9.2}/forgeline/cli.py

@@ -28,6 +28,9 @@ def main(argv=None):
         if name == "init": sp.add_argument("--root", default=".")
         elif name in {"architect","fill","review","arch-gate","verify-tests"}:
             sp.add_argument("feature"); sp.add_argument("ssat", nargs="?"); sp.add_argument("--root", default=".")
+            if name == "architect":
+                sp.add_argument("--dry-run", action="store_true", help="plan scaffold actions without writing files")
+                sp.add_argument("--force", action="store_true", help="overwrite existing targets after creating backups")
         elif name == "adopt":
             sp.add_argument("feature"); sp.add_argument("--root", default="."); sp.add_argument("--out", default=None); sp.add_argument("--force", action="store_true")
         elif name == "verify-tests-ts":
@@ -75,7 +78,10 @@ def main(argv=None):
             raise SystemExit(1)
     elif a.cmd == "architect":
         o = Orchestrator(root, a.feature)
-        print(json.dumps(o.architect(Path(a.ssat)), indent=2))
+        result = o.architect(Path(a.ssat), force=a.force, dry_run=a.dry_run)
+        print(json.dumps(result, indent=2))
+        if not result["scaffolded"] and not a.dry_run:
+            raise SystemExit(1)
     elif a.cmd == "fill":
         result = Orchestrator(root, a.feature).fill(Path(a.ssat))
         print(json.dumps(result, indent=2))

{code_factory_2_forge-0.9.0 → code_factory_2_forge-0.9.2}/forgeline/gates/typescript_mutants.py

@@ -27,13 +27,33 @@ def verify_typescript_tests(root: Path, feature: str, manifest_path: Path | None
         shutil.copytree(root, tmp, dirs_exist_ok=True, ignore=shutil.ignore_patterns(".git", "node_modules", "dist", "build", ".next", "coverage", ".forge"))
         units = []
         for mutant in mutants:
+            required = ("name", "path", "replace_regex", "command")
+            if (not isinstance(mutant, dict) or
+                    not all(isinstance(mutant.get(key), str) and mutant[key] for key in required) or
+                    not isinstance(mutant.get("replacement"), str)):
+                units.append(UnitResult("typescript:manifest", "verify_tests_ts", False, "each mutant requires non-empty name, path, replace_regex, and command strings plus a replacement string", FailureClass.HOLLOW_MANIFEST))
+                continue
             name = mutant["name"]
             target = tmp / mutant["path"]
             if not target.exists():
                 units.append(UnitResult(f"typescript:{name}", "verify_tests_ts", False, f"mutant target missing: {mutant['path']}", FailureClass.HOLLOW_MANIFEST))
                 continue
+            # A failing command before mutation is not proof that the mutant was killed.
+            try:
+                baseline = subprocess.run(mutant["command"], cwd=tmp, shell=True, capture_output=True, text=True,
+                                          timeout=int(mutant.get("timeout_s", 60)))
+            except subprocess.TimeoutExpired:
+                units.append(UnitResult(f"typescript:{name}", "verify_tests_ts", False, "baseline test command timed out", FailureClass.HOLLOW_MANIFEST))
+                continue
+            if baseline.returncode != 0:
+                units.append(UnitResult(f"typescript:{name}", "verify_tests_ts", False, f"baseline test command failed before mutation (exit {baseline.returncode})", FailureClass.HOLLOW_MANIFEST))
+                continue
             source = target.read_text(encoding="utf-8")
-            changed, count = re.subn(mutant["replace_regex"], mutant["replacement"], source, count=1, flags=re.S)
+            try:
+                changed, count = re.subn(mutant["replace_regex"], mutant["replacement"], source, count=1, flags=re.S)
+            except re.error as error:
+                units.append(UnitResult(f"typescript:{name}", "verify_tests_ts", False, f"invalid reviewed mutation regex: {error}", FailureClass.HOLLOW_MANIFEST))
+                continue
             if count != 1:
                 units.append(UnitResult(f"typescript:{name}", "verify_tests_ts", False, "reviewed mutation did not match exactly once", FailureClass.HOLLOW_MANIFEST))
                 continue

{code_factory_2_forge-0.9.0 → code_factory_2_forge-0.9.2}/forgeline/orchestrator.py

@@ -7,7 +7,7 @@ import shutil, subprocess, sys
 from pathlib import Path
 from .states import State, can_transition, IllegalTransition, HUMAN_GATES
 from .run_store import RunStore
-from .ssat import load_ssat, scaffold_from_ssat, check_erosion
+from .ssat import ScaffoldError, load_ssat, scaffold_from_ssat, check_erosion
 from .gates import judge_consistency, grumpy_review, skill_check
 from .gates.qa_audit import qa_audit
 from .skill_memory import record_lesson, inject_lessons_block, lessons_for
@@ -16,6 +16,20 @@ from .attribution import Attribution, FailureClass, UnitResult
 
 MAX_REFINE = 3
 
+_NEXT_ACTION = {
+    State.INTENT: "forge expand <feature> --root .",
+    State.EXPANDED: "forge gate architected <feature> --root .",
+    State.ARCHITECTED: "forge architect <feature> <ssat.yaml> --root .",
+    State.SCAFFOLDED: "forge fill <feature> <ssat.yaml> --root .",
+    State.FILLED: "forge review <feature> <ssat.yaml> --root .",
+    State.REVIEWED: "forge arch-gate <feature> <ssat.yaml> --root .",
+    State.ARCH_GATED: "forge verify-tests <feature> <ssat.yaml> --root .",
+    State.TESTS_VERIFIED: "forge smoke <feature> --root .",
+    State.SMOKED: "forge ship <feature> --root .",
+    State.BLOCKED: "inspect the failed receipt, repair it, then rerun its gate",
+    State.SHIPPED: "no further action; feature is shipped",
+}
+
 
 def _gate_attribution(stage: str, checks: list[tuple[str, bool, str, FailureClass]]) -> dict:
     units = [
@@ -67,12 +81,38 @@ class Orchestrator:
         self._advance(State.FILLED, "implemented bodies verified", attribution=attr)
         return {"filled": True, "attribution": attr}
 
-    def architect(self, ssat_path: Path) -> dict:
-        ssat = load_ssat(ssat_path)
-        created = scaffold_from_ssat(ssat, self.root)
-        self._advance(State.SCAFFOLDED, "scaffold from SSAT",
-                      modules=len(ssat.get("modules", [])), files=[str(c) for c in created])
-        return {"scaffolded": [str(c) for c in created]}
+    def architect(self, ssat_path: Path, *, force: bool = False, dry_run: bool = False) -> dict:
+        """Safely materialize the SSAT scaffold only from an allowed state."""
+        current = self.store.state
+        if current not in {State.ARCHITECTED, State.BLOCKED}:
+            return {
+                "scaffolded": False,
+                "error": {
+                    "code": "E_ILLEGAL_TRANSITION",
+                    "current_state": current.value,
+                    "requested_state": State.SCAFFOLDED.value,
+                    "next": _NEXT_ACTION[current],
+                },
+            }
+        try:
+            report = scaffold_from_ssat(
+                load_ssat(ssat_path), self.root, force=force, dry_run=dry_run,
+            )
+        except ScaffoldError as error:
+            return {"scaffolded": False, "error": {"code": "E_SCAFFOLD", "message": str(error)},
+                    "report": error.report.to_dict()}
+        result = {"scaffolded": not dry_run, "report": report.to_dict()}
+        if dry_run:
+            return result
+        self._advance(
+            State.SCAFFOLDED,
+            "scaffold from SSAT",
+            modules=len(load_ssat(ssat_path).get("modules", [])),
+            created=[item.to_dict() for item in report.created],
+            overwritten=[item.to_dict() for item in report.overwritten],
+            skipped=[item.to_dict() for item in report.skipped],
+        )
+        return result
 
     def review(self, ssat_path: Path) -> dict:
         """Judge + grumpy adversary + arch erosion + deep QA audit, with a

code_factory_2_forge-0.9.2/forgeline/ssat.py

@@ -0,0 +1,345 @@
+"""Semantic Software Architecture Tree: executable, language-aware contracts."""
+from __future__ import annotations
+
+import ast
+import hashlib
+import os
+import re
+import shutil
+import tempfile
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+import yaml
+
+
+@dataclass
+class ArchViolation:
+    code: str
+    message: str
+    where: str = ""
+
+
+class ScaffoldError(RuntimeError):
+    """A safe scaffold failure with a machine-readable report."""
+
+    def __init__(self, message: str, report: "ScaffoldReport"):
+        super().__init__(message)
+        self.report = report
+
+
+@dataclass
+class ScaffoldFile:
+    path: str
+    action: str
+    before_sha256: str | None = None
+    after_sha256: str | None = None
+    backup: str | None = None
+    detail: str | None = None
+
+    def to_dict(self) -> dict:
+        return {
+            "path": self.path,
+            "action": self.action,
+            "before_sha256": self.before_sha256,
+            "after_sha256": self.after_sha256,
+            "backup": self.backup,
+            "detail": self.detail,
+        }
+
+
+@dataclass
+class ScaffoldReport:
+    dry_run: bool
+    created: list[ScaffoldFile] = field(default_factory=list)
+    skipped: list[ScaffoldFile] = field(default_factory=list)
+    conflicts: list[ScaffoldFile] = field(default_factory=list)
+    overwritten: list[ScaffoldFile] = field(default_factory=list)
+    rollback_performed: bool = False
+
+    @property
+    def created_paths(self) -> list[Path]:
+        return [Path(item.path) for item in self.created]
+
+    def __len__(self) -> int:
+        """Compatibility for callers that previously received ``list[Path]``."""
+        return len(self.created)
+
+    def __iter__(self):
+        return iter(self.created_paths)
+
+    def to_dict(self) -> dict:
+        return {
+            "dry_run": self.dry_run,
+            "created": [item.to_dict() for item in self.created],
+            "skipped": [item.to_dict() for item in self.skipped],
+            "conflicts": [item.to_dict() for item in self.conflicts],
+            "overwritten": [item.to_dict() for item in self.overwritten],
+            "rollback_performed": self.rollback_performed,
+        }
+
+
+_LANGUAGE_BY_SUFFIX = {".py": "python", ".ts": "typescript", ".tsx": "typescript"}
+
+
+def load_ssat(path: Path) -> dict:
+    return yaml.safe_load(Path(path).read_text(encoding="utf-8"))
+
+
+def _sha256_bytes(value: bytes) -> str:
+    return hashlib.sha256(value).hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    return _sha256_bytes(path.read_bytes())
+
+
+def _language_for(path: Path) -> str:
+    language = _LANGUAGE_BY_SUFFIX.get(path.suffix.lower())
+    if language is None:
+        raise ValueError(f"unsupported SSAT module extension: {path.suffix or '<none>'}")
+    return language
+
+
+def _python_import(imp: str) -> str:
+    return f"import {imp}" if "." not in imp else f"from {imp.rsplit('.', 1)[0]} import {imp.rsplit('.', 1)[1]}"
+
+
+def _typescript_import(imp: str) -> str:
+    if imp.startswith("import "):
+        return imp
+    alias = re.sub(r"[^A-Za-z0-9_]", "_", imp.rsplit("/", 1)[-1]) or "module_"
+    source = imp if imp.startswith((".", "/")) else f"./{imp}"
+    return f'import * as {alias} from "{source}";'
+
+
+def _render_python(module: dict) -> str:
+    lines = ['"""AUTO-SCAFFOLD from SSAT. Fill bodies only; do not change signatures."""']
+    lines.extend(_python_import(imp) for imp in module.get("imports", []))
+    lines.append("")
+    for function in module.get("functions", []):
+        args = ", ".join(function.get("args", []))
+        returns = function.get("returns", "None")
+        lines.extend([
+            f"def {function['name']}({args}) -> {returns}:",
+            f'    """{function.get("doc", "TODO")}"""',
+            "    raise NotImplementedError  # FILL",
+            "",
+        ])
+    return "\n".join(lines)
+
+
+def _render_typescript(module: dict) -> str:
+    lines = ["/** AUTO-SCAFFOLD from SSAT. Fill bodies only; do not change signatures. */"]
+    lines.extend(_typescript_import(imp) for imp in module.get("imports", []))
+    lines.append("")
+    for function in module.get("functions", []):
+        args = ", ".join(function.get("args", []))
+        returns = function.get("returns", "void")
+        lines.extend([
+            f"/** {function.get('doc', 'TODO')} */",
+            f"export function {function['name']}({args}): {returns} {{",
+            '  throw new Error("NotImplementedError: FILL");',
+            "}",
+            "",
+        ])
+    return "\n".join(lines)
+
+
+def _render_module(module: dict, target: Path) -> str:
+    language = _language_for(target)
+    if language == "python":
+        return _render_python(module)
+    return _render_typescript(module)
+
+
+def _validate_generated_source(source: str, target: Path) -> None:
+    language = _language_for(target)
+    if language == "python":
+        ast.parse(source)
+        return
+    if re.search(r"^\s*def\s+", source, flags=re.MULTILINE) or source.count("{") != source.count("}"):
+        raise ValueError(f"generated invalid TypeScript for {target}")
+    for line in source.splitlines():
+        if "export function " in line and not re.search(r"export function \w+\(.*\):\s*[^\s]+\s*\{", line):
+            raise ValueError(f"generated invalid TypeScript signature for {target}")
+
+
+def scaffold_from_ssat(
+    ssat: dict,
+    out_dir: Path,
+    *,
+    force: bool = False,
+    dry_run: bool = False,
+    backup_root: Path | None = None,
+) -> ScaffoldReport:
+    """Plan, validate, and atomically materialize a language-aware SSAT scaffold.
+
+    Existing files are conflicts by default. ``force=True`` creates a timestamped
+    backup before an atomic replacement. No target is changed until every module
+    has rendered and validated; any write failure restores every earlier target.
+    """
+    out_dir = Path(out_dir).resolve()
+    report = ScaffoldReport(dry_run=dry_run)
+    plan: list[tuple[dict, Path, str, bytes | None]] = []
+    seen: set[Path] = set()
+
+    try:
+        for module in ssat.get("modules", []):
+            target = (out_dir / module["path"]).resolve()
+            if out_dir not in target.parents and target != out_dir:
+                raise ValueError(f"SSAT module path escapes root: {module['path']}")
+            if target in seen:
+                raise ValueError(f"SSAT declares duplicate module path: {module['path']}")
+            seen.add(target)
+            source = _render_module(module, target)
+            _validate_generated_source(source, target)
+            previous = target.read_bytes() if target.exists() else None
+            action = "overwrite" if previous is not None and force else "conflict" if previous is not None else "create"
+            item = ScaffoldFile(
+                path=str(target),
+                action=action,
+                before_sha256=_sha256_bytes(previous) if previous is not None else None,
+                after_sha256=_sha256_bytes(source.encode("utf-8")),
+            )
+            if action == "conflict":
+                report.conflicts.append(item)
+            elif action == "overwrite":
+                report.overwritten.append(item)
+            else:
+                report.created.append(item)
+            plan.append((module, target, source, previous))
+    except (KeyError, TypeError, ValueError) as exc:
+        raise ScaffoldError(str(exc), report) from exc
+
+    if report.conflicts:
+        raise ScaffoldError("existing SSAT targets require --force", report)
+    if dry_run:
+        return report
+
+    temp_paths: list[tuple[Path, Path]] = []
+    backups: dict[Path, Path] = {}
+    created_targets = [target for _, target, _, previous in plan if previous is None]
+    try:
+        # Validate every temp file before changing a single target.
+        for _, target, source, _ in plan:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            fd, temp_name = tempfile.mkstemp(prefix=f".{target.name}.", suffix=".forge-tmp", dir=target.parent)
+            temp = Path(temp_name)
+            with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as handle:
+                handle.write(source)
+                handle.flush()
+                os.fsync(handle.fileno())
+            temp_paths.append((temp, target))
+
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+        backup_root = Path(backup_root) if backup_root else out_dir / ".forge" / "scaffold-backups" / timestamp
+        for _, target, _, previous in plan:
+            if previous is not None:
+                backup = backup_root / target.relative_to(out_dir)
+                backup.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(target, backup)
+                backups[target] = backup
+                next(item for item in report.overwritten if item.path == str(target)).backup = str(backup)
+
+        for temp, target in temp_paths:
+            os.replace(temp, target)
+        return report
+    except Exception as exc:
+        for target, backup in backups.items():
+            if backup.exists():
+                shutil.copy2(backup, target)
+        for target in created_targets:
+            if target.exists() and target not in backups:
+                target.unlink()
+        report.rollback_performed = bool(backups or created_targets)
+        raise ScaffoldError(f"scaffold transaction rolled back: {exc}", report) from exc
+    finally:
+        for temp, _ in temp_paths:
+            if temp.exists():
+                temp.unlink()
+
+
+def _module_of(path: str, ssat: dict) -> str | None:
+    for module in ssat.get("modules", []):
+        if path.endswith(module["path"]):
+            return module["name"]
+    return None
+
+
+def _typescript_erosion(module: dict, path: Path, names: dict, allowed: set[tuple[str, str]]) -> list[ArchViolation]:
+    """A TypeScript-specific structure check. Python's AST is never used here."""
+    source = path.read_text(encoding="utf-8")
+    violations: list[ArchViolation] = []
+    if re.search(r"^\s*def\s+", source, flags=re.MULTILINE) or source.count("{") != source.count("}"):
+        return [ArchViolation("E_TS_SYNTAX", "invalid TypeScript structure", module["path"])]
+    for function in module.get("functions", []):
+        pattern = re.compile(rf"(?:export\s+)?(?:async\s+)?function\s+{re.escape(function['name'])}\s*\(([^)]*)\)", re.MULTILINE)
+        match = pattern.search(source)
+        if match is None:
+            violations.append(ArchViolation("E_SIG_MISSING", f"{function['name']} declared but not implemented", module["path"]))
+            continue
+        got_args = [part.split(":", 1)[0].strip().rstrip("?") for part in match.group(1).split(",") if part.strip()]
+        want_args = [arg.split(":", 1)[0].strip().rstrip("?") for arg in function.get("args", [])]
+        if got_args != want_args:
+            violations.append(ArchViolation("E_SIG_DRIFT", f"{function['name']}({got_args}) != SSAT ({want_args})", module["path"]))
+    this = module["name"]
+    for imported in re.findall(r"(?:from\s+|import\s+)['\"]([^'\"]+)['\"]", source):
+        target = names.get(Path(imported).stem) or names.get(imported)
+        target_name = target["name"] if target else None
+        if target_name and target_name != this and (this, target_name) not in allowed:
+            violations.append(ArchViolation("E_ILLEGAL_DEP", f"{this} -> {target_name} not in SSAT dependency allowlist", module["path"]))
+    return violations
+
+
+def check_erosion(ssat: dict, src_dir: Path) -> list[ArchViolation]:
+    """Detect signature drift and illegal dependency edges per source language."""
+    src_dir = Path(src_dir)
+    violations: list[ArchViolation] = []
+    allowed = {(edge["from"], edge["to"]) for edge in ssat.get("dependencies", [])}
+    names = {module["name"]: module for module in ssat.get("modules", [])}
+    for module in ssat.get("modules", []):
+        path = src_dir / module["path"]
+        if not path.exists():
+            violations.append(ArchViolation("E_MISSING_MODULE", f"{module['path']} declared in SSAT but absent"))
+            continue
+        try:
+            language = _language_for(path)
+        except ValueError as exc:
+            violations.append(ArchViolation("E_UNSUPPORTED_LANGUAGE", str(exc), module["path"]))
+            continue
+        if language == "typescript":
+            violations.extend(_typescript_erosion(module, path, names, allowed))
+            continue
+        try:
+            tree = ast.parse(path.read_text(encoding="utf-8"))
+        except SyntaxError as exc:
+            violations.append(ArchViolation("E_SYNTAX", str(exc), module["path"]))
+            continue
+        declared = {function["name"]: function for function in module.get("functions", [])}
+        found = {node.name: node for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)}
+        for name, spec in declared.items():
+            if name not in found:
+                violations.append(ArchViolation("E_SIG_MISSING", f"{name} declared but not implemented", module["path"]))
+                continue
+            got_args = [arg.arg for arg in found[name].args.args]
+            want_args = [arg.split(":", 1)[0].strip() for arg in spec.get("args", [])]
+            if got_args != want_args:
+                violations.append(ArchViolation("E_SIG_DRIFT", f"{name}({got_args}) != SSAT ({want_args})", module["path"]))
+        this = module["name"]
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.Import, ast.ImportFrom)):
+                imports = [alias.name for alias in node.names] if isinstance(node, ast.Import) else [node.module or ""]
+                for imported in imports:
+                    target = names.get(imported.split(".")[-1]) or names.get(imported)
+                    target_name = target["name"] if target else None
+                    if target_name and target_name != this and (this, target_name) not in allowed:
+                        violations.append(ArchViolation("E_ILLEGAL_DEP", f"{this} -> {target_name} not in SSAT dependency allowlist", module["path"]))
+    for invariant in ssat.get("invariants", []):
+        pattern = invariant["forbid_pattern"]
+        for module in ssat.get("modules", []):
+            path = src_dir / module["path"]
+            if path.exists() and re.search(pattern, path.read_text(encoding="utf-8")):
+                violations.append(ArchViolation("E_INVARIANT", f"{invariant['name']}: forbidden pattern {pattern!r}", module["path"]))
+    return violations

{code_factory_2_forge-0.9.0 → code_factory_2_forge-0.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-factory-2-forge"
-version = "0.9.0"
+version = "0.9.2"
 description = "ForgeLine — the autonomous outer loop for AI software factories. A CLI-backed state machine that drives intent -> spec -> plan -> code -> adversarial review -> ship, orchestrating SpecLine (spec governance) and Harness Software Factory (compiled decisions), with self-improving skills and architecture-as-a-CI-gate."
 readme = "README.md"
 requires-python = ">=3.11"

{code_factory_2_forge-0.9.0 → code_factory_2_forge-0.9.2}/tests/test_forgeline.py

@@ -1,11 +1,14 @@
 import json
 import hashlib
+import shutil
+import subprocess
+import yaml
 from pathlib import Path
 import pytest
 from forgeline.states import State, can_transition, IllegalTransition
 from forgeline.run_store import RunStore
 from forgeline.orchestrator import Orchestrator
-from forgeline.ssat import load_ssat, scaffold_from_ssat, check_erosion
+from forgeline.ssat import ScaffoldError, load_ssat, scaffold_from_ssat, check_erosion
 from conftest import fill_good, write_smoke_manifest
 
 def test_state_machine_rejects_illegal_transitions():
@@ -47,6 +50,126 @@ def test_scaffold_generates_signatures_from_ssat(proj):
     text = (proj/"slices"/"notifier"/"formatter.py").read_text()
     assert "def format_message(event: dict) -> str:" in text and "NotImplementedError" in text
 
+
+def _typescript_ssat(paths: list[str]) -> dict:
+    return {
+        "name": "typescript-safety",
+        "modules": [
+            {
+                "name": Path(path).stem.replace("-", "_"),
+                "path": path,
+                "imports": [],
+                "functions": [{"name": "render", "args": ["name: string"], "returns": "string"}],
+            }
+            for path in paths
+        ],
+        "dependencies": [],
+        "invariants": [],
+    }
+
+
+def test_existing_typescript_target_conflicts_without_force_and_preserves_hash(proj, capsys):
+    target = proj / "src" / "memory.ts"
+    target.parent.mkdir(parents=True)
+    target.write_text("export const preserved = true;\n", encoding="utf-8")
+    before = hashlib.sha256(target.read_bytes()).hexdigest()
+    orchestrator = Orchestrator(proj, "notifier")
+    orchestrator.store.set_state(State.ARCHITECTED)
+    spec = proj / "typescript.ssat.yaml"
+    spec.write_text(yaml.safe_dump(_typescript_ssat(["src/memory.ts"])), encoding="utf-8")
+
+    from forgeline.cli import main
+    with pytest.raises(SystemExit) as exited:
+        main(["architect", "notifier", str(spec), "--root", str(proj)])
+    assert exited.value.code == 1
+    result = json.loads(capsys.readouterr().out)
+
+    assert result["scaffolded"] is False
+    assert result["error"]["code"] == "E_SCAFFOLD"
+    assert result["report"]["conflicts"][0]["path"] == str(target)
+    assert hashlib.sha256(target.read_bytes()).hexdigest() == before
+    assert orchestrator.store.state == State.ARCHITECTED
+
+
+def test_typescript_ssat_generates_typescript_and_compiles_when_tsc_is_available(proj):
+    report = scaffold_from_ssat(_typescript_ssat(["src/memory.ts"]), proj)
+    target = proj / "src" / "memory.ts"
+    source = target.read_text(encoding="utf-8")
+    assert len(report) == 1
+    assert "export function render(name: string): string" in source
+    assert "def render" not in source
+    tsc = shutil.which("tsc")
+    if tsc is None:
+        pytest.skip("tsc is installed by CI for the TypeScript scaffold regression")
+    completed = subprocess.run([tsc, "--noEmit", "--pretty", "false", str(target)], capture_output=True, text=True)
+    assert completed.returncode == 0, completed.stdout + completed.stderr
+
+
+def test_mixed_language_ssat_generates_each_language_and_rejects_unknown_extensions(proj):
+    report = scaffold_from_ssat(_typescript_ssat(["src/memory.ts", "src/worker.py"]), proj)
+    assert len(report.created) == 2
+    assert "export function render" in (proj / "src" / "memory.ts").read_text(encoding="utf-8")
+    assert "def render" in (proj / "src" / "worker.py").read_text(encoding="utf-8")
+    with pytest.raises(ScaffoldError) as raised:
+        scaffold_from_ssat(_typescript_ssat(["src/not-supported.go"]), proj)
+    assert "unsupported SSAT module extension" in str(raised.value)
+    assert not (proj / "src" / "not-supported.go").exists()
+
+
+def test_scaffold_second_write_failure_restores_prior_files_byte_for_byte(proj, monkeypatch):
+    spec = _typescript_ssat(["src/a.ts", "src/b.ts"])
+    first = proj / "src" / "a.ts"
+    second = proj / "src" / "b.ts"
+    first.parent.mkdir(parents=True)
+    first.write_text("export const originalA = true;\n", encoding="utf-8")
+    second.write_text("export const originalB = true;\n", encoding="utf-8")
+    original_first, original_second = first.read_bytes(), second.read_bytes()
+
+    from forgeline import ssat as ssat_module
+    real_replace = ssat_module.os.replace
+
+    def fail_second_temp(source, target):
+        if Path(target) == second and str(source).endswith(".forge-tmp"):
+            raise OSError("simulated second-file replace failure")
+        return real_replace(source, target)
+
+    monkeypatch.setattr(ssat_module.os, "replace", fail_second_temp)
+    with pytest.raises(ScaffoldError) as raised:
+        scaffold_from_ssat(spec, proj, force=True)
+
+    assert raised.value.report.rollback_performed is True
+    assert first.read_bytes() == original_first
+    assert second.read_bytes() == original_second
+
+
+def test_scaffold_report_never_calls_preexisting_target_created(proj):
+    target = proj / "src" / "present.ts"
+    target.parent.mkdir(parents=True)
+    target.write_text("export const before = true;\n", encoding="utf-8")
+    report = scaffold_from_ssat(_typescript_ssat(["src/present.ts", "src/new.ts"]), proj, force=True)
+    assert [Path(item.path).name for item in report.created] == ["new.ts"]
+    assert [Path(item.path).name for item in report.overwritten] == ["present.ts"]
+
+
+def test_architect_illegal_transition_returns_structured_error_without_traceback(proj, capsys):
+    orchestrator = Orchestrator(proj, "notifier")
+    orchestrator.store.set_state(State.EXPANDED)
+    from forgeline.cli import main
+    with pytest.raises(SystemExit) as exited:
+        main(["architect", "notifier", str(proj / "notifier.ssat.yaml"), "--root", str(proj)])
+    assert exited.value.code == 1
+    captured = capsys.readouterr()
+    assert "Traceback" not in captured.err
+    result = json.loads(captured.out)
+    assert result["scaffolded"] is False
+    assert result["error"] == {
+        "code": "E_ILLEGAL_TRANSITION",
+        "current_state": "expanded",
+        "requested_state": "scaffolded",
+        "next": "forge gate architected <feature> --root .",
+    }
+    assert not (proj / "slices" / "notifier" / "formatter.py").exists()
+
 def test_arch_erosion_detects_signature_drift(proj):
     ssat = load_ssat(proj/"notifier.ssat.yaml")
     scaffold_from_ssat(ssat, proj)
@@ -535,6 +658,33 @@ def test_typescript_mutant_verification_requires_existing_test_to_fail(tmp_path)
     assert result.attribution.n_passed == 1
 
 
+def test_typescript_mutant_verification_refuses_a_broken_baseline(tmp_path):
+    from forgeline.gates.typescript_mutants import verify_typescript_tests
+
+    (tmp_path / "src").mkdir()
+    (tmp_path / ".forge" / "math").mkdir(parents=True)
+    (tmp_path / "src" / "sum.ts").write_text("export const sum = () => 2;")
+    manifest = {"mutants": [{
+        "name": "sum_stub", "path": "src/sum.ts", "replace_regex": "=> 2", "replacement": "=> 0",
+        "command": "python -c \"raise SystemExit(1)\"",
+    }]}
+    (tmp_path / ".forge" / "math" / "typescript-mutants.json").write_text(json.dumps(manifest))
+    result = verify_typescript_tests(tmp_path, "math")
+    assert result.passed is False
+    assert result.attribution.failures[0].failure_class.value == "hollow_manifest"
+    assert "before mutation" in result.attribution.failures[0].evidence
+
+
+def test_typescript_mutant_verification_rejects_incomplete_manifest(tmp_path):
+    from forgeline.gates.typescript_mutants import verify_typescript_tests
+
+    (tmp_path / ".forge" / "math").mkdir(parents=True)
+    (tmp_path / ".forge" / "math" / "typescript-mutants.json").write_text(json.dumps({"mutants": [{"name": "missing-fields"}]}))
+    result = verify_typescript_tests(tmp_path, "math")
+    assert result.passed is False
+    assert result.attribution.failures[0].failure_class.value == "hollow_manifest"
+
+
 def test_verify_tests_temp_root_is_cleaned_up(proj):
     import tempfile
     o = _to_arch_gated(proj)

code_factory_2_forge-0.9.0/forgeline/ssat.py

@@ -1,93 +0,0 @@
-"""Semantic Software Architecture Tree — architecture as code, not a doc.
-
-An SSAT is a YAML contract: modules, their public signatures, allowed
-dependency edges, and invariants. It is BOTH the scaffold source AND the
-CI gate — the same artifact that generates the skeleton also detects
-'structural erosion' when filled code violates the declared boundaries.
-"""
-from __future__ import annotations
-import ast, re
-from dataclasses import dataclass, field
-from pathlib import Path
-import yaml
-
-@dataclass
-class ArchViolation:
-    code: str
-    message: str
-    where: str = ""
-
-def load_ssat(path: Path) -> dict:
-    return yaml.safe_load(Path(path).read_text())
-
-def scaffold_from_ssat(ssat: dict, out_dir: Path) -> list[Path]:
-    """Generate signature-only files with valid imports from the SSAT."""
-    out_dir = Path(out_dir); created = []
-    for mod in ssat.get("modules", []):
-        p = out_dir/mod["path"]
-        p.parent.mkdir(parents=True, exist_ok=True)
-        lines = ['"""AUTO-SCAFFOLD from SSAT. Fill bodies only; do not change signatures."""']
-        for imp in mod.get("imports", []):
-            lines.append(f"import {imp}" if "." not in imp else f"from {imp.rsplit('.',1)[0]} import {imp.rsplit('.',1)[1]}")
-        lines.append("")
-        for fn in mod.get("functions", []):
-            args = ", ".join(fn.get("args", []))
-            ret = fn.get("returns", "None")
-            lines.append(f"def {fn['name']}({args}) -> {ret}:")
-            lines.append(f'    """{fn.get("doc","TODO")}"""')
-            lines.append("    raise NotImplementedError  # FILL")
-            lines.append("")
-        p.write_text("\n".join(lines)); created.append(p)
-    return created
-
-def _module_of(path: str, ssat: dict) -> str | None:
-    for mod in ssat.get("modules", []):
-        if path.endswith(mod["path"]):
-            return mod["name"]
-    return None
-
-def check_erosion(ssat: dict, src_dir: Path) -> list[ArchViolation]:
-    """Architecture-as-CI-gate: detect signature drift + illegal dependency edges."""
-    src_dir = Path(src_dir); violations = []
-    allowed = {(e["from"], e["to"]) for e in ssat.get("dependencies", [])}
-    names = {m["name"]: m for m in ssat.get("modules", [])}
-    path_to_name = {m["path"]: m["name"] for m in ssat.get("modules", [])}
-    for mod in ssat.get("modules", []):
-        p = src_dir/mod["path"]
-        if not p.exists():
-            violations.append(ArchViolation("E_MISSING_MODULE", f"{mod['path']} declared in SSAT but absent"))
-            continue
-        try:
-            tree = ast.parse(p.read_text())
-        except SyntaxError as e:
-            violations.append(ArchViolation("E_SYNTAX", str(e), mod["path"])); continue
-        # signature drift
-        declared = {f["name"]: f for f in mod.get("functions", [])}
-        found = {n.name: n for n in ast.walk(tree) if isinstance(n, ast.FunctionDef)}
-        for fname, fspec in declared.items():
-            if fname not in found:
-                violations.append(ArchViolation("E_SIG_MISSING", f"{fname} declared but not implemented", mod["path"]))
-                continue
-            got_args = [a.arg for a in found[fname].args.args]
-            want_args = [a.split(":")[0].strip() for a in fspec.get("args", [])]
-            if got_args != want_args:
-                violations.append(ArchViolation("E_SIG_DRIFT",
-                    f"{fname}({got_args}) != SSAT ({want_args})", mod["path"]))
-        # illegal dependency edges
-        this = mod["name"]
-        for node in ast.walk(tree):
-            if isinstance(node, (ast.Import, ast.ImportFrom)):
-                mods = [a.name for a in node.names] if isinstance(node, ast.Import) else [node.module or ""]
-                for m in mods:
-                    target = names.get(m.split(".")[-1]) or names.get(m)
-                    tname = target["name"] if target else None
-                    if tname and tname != this and (this, tname) not in allowed:
-                        violations.append(ArchViolation("E_ILLEGAL_DEP",
-                            f"{this} -> {tname} not in SSAT dependency allowlist", mod["path"]))
-    for inv in ssat.get("invariants", []):
-        pat = inv["forbid_pattern"]
-        for mod in ssat.get("modules", []):
-            p = src_dir/mod["path"]
-            if p.exists() and re.search(pat, p.read_text()):
-                violations.append(ArchViolation("E_INVARIANT", f"{inv['name']}: forbidden pattern {pat!r}", mod["path"]))
-    return violations