base120 2.0.0__py3-none-any.whl

base120/__init__.py

@@ -0,0 +1,79 @@
+# Copyright 2024-2026 HUMMBL, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""base120 — 120 reasoning operators for structured thinking.
+
+Version 2 of the base120 Python SDK. Stdlib-only. Zero third-party runtime
+dependencies. Tuple-native output aligned to the VERUM sovereignty model.
+
+Quick start::
+
+    from base120 import Engine
+
+    engine = Engine()
+
+    # Discover operators
+    op = engine.get("P6")           # Operator(code='P6', name='Point-of-View Anchoring', ...)
+    ops = engine.list(family="DE")  # 20 Decomposition operators
+
+    # Generate a system prompt for any LLM
+    prompt = engine.prompt("P6", "How should we price the certification tier?")
+
+    # Record an application as a governance artifact
+    result = engine.record("P6", "How should...", "Anchor to compliance officer POV", 0.85)
+    t = result.to_tuple()  # OperatorTuple(id='P6', time='...Z', state='...', drift=0.15)
+    # Append to the VERUM audit ledger
+    from base120 import Ledger
+    ledger = Ledger()
+    ledger.append(t)                  # ~/.base120/ledger.jsonl
+    high_drift = ledger.cut(0.5)      # entries with drift > 0.5
+
+VERUM alignment:
+  to_tuple() fields map to the 4 VERUM node fields:
+    id    → who/what (operator code)
+    time  → when     (UTC ISO-8601)
+    state → current condition (recommendation)
+    drift → deviation from setpoint (1.0 - confidence)
+
+CLI::
+
+    base120 list
+    base120 list --family DE
+    base120 get P6
+    base120 prompt P6 "your problem here"
+    base120 families
+
+Apache 2.0. Copyright 2026 HUMMBL, LLC.
+"""
+
+from __future__ import annotations
+
+from base120.engine import FAMILIES, FAMILY_NAMES, Engine
+from base120.ledger import Ledger
+from base120.models import ApplyResult, Operator, OperatorTuple
+
+__version__ = "2.0.0"
+
+__all__ = [
+    "FAMILIES",
+    "FAMILY_NAMES",
+    "ApplyResult",
+    "Engine",
+    "Ledger",
+    "Operator",
+    "OperatorTuple",
+    "__version__",
+]

base120/cli.py

@@ -0,0 +1,131 @@
+# Copyright 2024-2026 HUMMBL, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Base120 CLI.
+
+Commands:
+  base120 list                    — list all 120 operators
+  base120 list --family DE        — list operators for one family
+  base120 get P6                  — show one operator's details
+  base120 prompt P6 "problem"     — generate a system prompt
+  base120 families                — list the 6 families with descriptions
+
+Stdlib only. Zero third-party dependencies.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from base120.engine import FAMILY_NAMES, Engine
+
+
+def _cmd_list(engine: Engine, args: argparse.Namespace) -> int:
+    family: str | None = args.family
+    ops = engine.list(family=family)
+    if not ops:
+        print(f"No operators found for family {family!r}.", file=sys.stderr)
+        return 1
+    if family:
+        fname = FAMILY_NAMES.get(family.upper(), family.upper())
+        print(f"{fname} ({family.upper()}) — {len(ops)} operators\n")
+    for op in ops:
+        print(f"  {op.code:<6}  {op.name}")
+    return 0
+
+
+def _cmd_get(engine: Engine, args: argparse.Namespace) -> int:
+    op = engine.get(args.code)
+    if op is None:
+        print(f"Unknown operator code: {args.code!r}", file=sys.stderr)
+        return 1
+    fname = FAMILY_NAMES.get(op.transformation, op.transformation)
+    print(f"{op.code}: {op.name}")
+    print(f"  Family:     {op.transformation} — {fname}")
+    print(f"  Definition: {op.definition}")
+    return 0
+
+
+def _cmd_prompt(engine: Engine, args: argparse.Namespace) -> int:
+    try:
+        prompt = engine.prompt(args.code, args.problem)
+    except ValueError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+    print(prompt)
+    return 0
+
+
+def _cmd_families(engine: Engine, _args: argparse.Namespace) -> int:
+    for fam in engine.families():
+        name = FAMILY_NAMES.get(fam, fam)
+        ops = engine.list(family=fam)
+        print(f"  {fam:<4}  {name:<16}  {len(ops)} operators")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="base120",
+        description="Base120 — 120 reasoning operators for structured thinking.",
+    )
+    sub = parser.add_subparsers(dest="command", metavar="command")
+    sub.required = True
+
+    # list
+    p_list = sub.add_parser("list", help="List operators")
+    p_list.add_argument(
+        "--family",
+        metavar="FAMILY",
+        help="Filter by family: P, IN, CO, DE, RE, SY",
+    )
+
+    # get
+    p_get = sub.add_parser("get", help="Show operator details")
+    p_get.add_argument("code", help="Operator code, e.g. P6 or DE1")
+
+    # prompt
+    p_prompt = sub.add_parser("prompt", help="Generate a system prompt")
+    p_prompt.add_argument("code", help="Operator code, e.g. P6")
+    p_prompt.add_argument("problem", help="Problem statement to reason about")
+
+    # families
+    sub.add_parser("families", help="List the 6 operator families")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    engine = Engine()
+
+    dispatch = {
+        "list":     _cmd_list,
+        "get":      _cmd_get,
+        "prompt":   _cmd_prompt,
+        "families": _cmd_families,
+    }
+    handler = dispatch.get(args.command)
+    if handler is None:
+        parser.print_help()
+        return 1
+    return handler(engine, args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())