arc-kernel 0.1.0__py3-none-any.whl

arc/runtime.py

@@ -0,0 +1,189 @@
+"""
+arc.runtime
+------------------
+`arc.boot()` — the runtime counterpart to the CLI tooling. The CLI mutates the
+project (install/build/enable); boot() only ever reads it.
+
+Boot contract (Architecture §3.6):
+  * runs at EVERY process start,
+  * read-only — never mutates plugins.lock, settings, or anything on disk,
+  * fully offline — no git, no PyPI,
+  * safe to run on every replica simultaneously,
+  * idempotent within a process — a second boot() is a no-op returning the
+    same Kernel; pass force=True to rebuild (tests, embedding).
+
+Sequence:
+  1. locate the project root: explicit argument > $ARC_PROJECT_ROOT > walk up
+     from cwd looking for .arc/arc.toml;
+  2. read .arc/plugins.lock (source of truth for what is enabled) and the
+     installed `arc.plugins` entry points;
+  3. resolve a BootPlan (arc.resolver — pure; the same function powers
+     `arc doctor` as a dry run);
+  4. bind this project's SettingsManager onto the Kernel, making the
+     module-level arc.settings API live (§3.5);
+  5. call each plugin's register(kernel) in topological order — the active
+     kernel is published *before* execution, so a plugin may use
+     arc.<earlier_capability> and arc.settings inside register();
+  6. every exported capability becomes reachable as arc.<name> via the
+     package's PEP 562 __getattr__.
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+from pathlib import Path
+from typing import Any, Iterable
+
+from . import _state
+from .kernel import Kernel, KernelError
+from .registry import load_lock
+from .resolver import PluginSpec, discover_entry_points, resolve
+from .settings import SettingsManager
+
+
+class BootError(KernelError):
+    """arc.boot() could not start the process."""
+
+
+_boot_lock = threading.Lock()
+
+
+def find_project_root(start: Path | None = None) -> Path | None:
+    """
+    Locate the ARC project root. $ARC_PROJECT_ROOT wins when set (and is
+    validated loudly — explicit configuration that is wrong should never be
+    silently ignored); otherwise walk up from `start`/cwd looking for
+    .arc/arc.toml. Returns None when no project is found.
+    """
+    env_root = os.environ.get("ARC_PROJECT_ROOT")
+    if env_root:
+        root = Path(env_root).expanduser().resolve()
+        if not (root / ".arc" / "arc.toml").exists():
+            raise BootError(
+                f"$ARC_PROJECT_ROOT is set to '{root}', but no .arc/arc.toml "
+                f"exists there — fix or unset the variable."
+            )
+        return root
+
+    current = (start or Path.cwd()).resolve()
+    for candidate in (current, *current.parents):
+        if (candidate / ".arc" / "arc.toml").exists():
+            return candidate
+    return None
+
+
+def boot(
+    project_root: str | Path | None = None,
+    *,
+    force: bool = False,
+    entry_points: Iterable[Any] | None = None,
+) -> Kernel:
+    """
+    Boot the ARC runtime for this process and return the Kernel.
+
+    `entry_points` overrides installed-entry-point discovery — for tests and
+    embedding; production callers never pass it.
+    """
+    with _boot_lock:
+        existing = _state.get_kernel()
+        if existing is not None:
+            if not force:
+                return existing
+            _state.set_kernel(None)
+
+        if project_root is not None:
+            root = Path(project_root).expanduser().resolve()
+            if not (root / ".arc" / "arc.toml").exists():
+                raise BootError(
+                    f"project_root was given as '{root}', but no .arc/arc.toml "
+                    f"exists there — is this really an ARC project? "
+                    f"Run `arc init` first."
+                )
+        else:
+            root = find_project_root()
+            if root is None:
+                raise BootError(
+                    "Not inside an ARC project — no .arc/arc.toml found in the "
+                    "current directory or any parent. Run from within a project, "
+                    "pass boot(project_root=...), or set $ARC_PROJECT_ROOT."
+                )
+
+        lock_doc = load_lock(root / ".arc" / "plugins.lock")
+        eps = tuple(entry_points) if entry_points is not None else discover_entry_points()
+        plan = resolve(root, lock_doc=lock_doc, entry_points=eps)
+
+        settings_manager = SettingsManager(root / ".arc")
+        kernel = Kernel(project_root=root, settings=settings_manager, plan=plan)
+
+        for warning in plan.warnings:
+            kernel.advise(warning)
+        if settings_manager.secrets_provider() == "local_file":
+            # §3.5: fully supported tier for dev/self-hosted — advisory, never an error.
+            kernel.advise(
+                "local-file secrets provider in use (.arc/arc.secrets encrypted "
+                "with .arc/arc.mkey) — a supported tier for dev and self-hosted "
+                "deployments. For managed environments, consider a keyring/KMS "
+                "provider via [secrets].provider in .arc/arc.toml. Advisory only; "
+                "startup is never blocked."
+            )
+
+        # Publish BEFORE executing registers: topological order means a plugin
+        # may legitimately use arc.<earlier_capability> and arc.settings inside
+        # its own register(). Any failure below tears this back down.
+        _state.set_kernel(kernel)
+        try:
+            for spec in plan.load_order:
+                register = _load_register(spec)
+                kernel._begin_plugin(spec)
+                try:
+                    register(kernel)
+                except KernelError:
+                    raise
+                except Exception as exc:
+                    raise BootError(
+                        f"plugin '{spec.name}' raised during register(): "
+                        f"{exc.__class__.__name__}: {exc}"
+                    ) from exc
+                kernel._finish_plugin(spec)
+        except BaseException:
+            _state.set_kernel(None)
+            raise
+        return kernel
+
+
+def shutdown() -> None:
+    """
+    Clear the process-wide kernel so the next boot() starts fresh. Primarily
+    for tests and embedding. No lifecycle/teardown hooks are invoked — that
+    surface belongs to the future arc.health/lifecycle design, not here.
+    """
+    _state.set_kernel(None)
+
+
+def _load_register(spec: PluginSpec) -> Any:
+    """Import the plugin's entry point and return its register(kernel) callable."""
+    ep = spec.entry_point
+    if ep is None:  # defensive: resolve() always attaches one for enabled specs
+        raise BootError(
+            f"plugin '{spec.name}' has no entry point attached — internal "
+            f"resolution error."
+        )
+    try:
+        target = ep.load()
+    except Exception as exc:
+        raise BootError(
+            f"could not import plugin '{spec.name}' "
+            f"(entry point '{getattr(ep, 'value', '?')}'): "
+            f"{exc.__class__.__name__}: {exc}"
+        ) from exc
+    if callable(target):
+        return target
+    register = getattr(target, "register", None)
+    if callable(register):
+        return register
+    raise BootError(
+        f"the entry point for plugin '{spec.name}' must reference a callable "
+        f"register(kernel) function (e.g. \"{spec.name} = 'yourpkg:register'\") "
+        f"or a module defining one — got {type(target).__name__}."
+    )

arc/secrets.py

@@ -0,0 +1,85 @@
+"""
+arc.secrets
+------------------
+Local-file secrets provider.
+
+This is the dev / self-hosted default described in the ARC settings design:
+values are encrypted at rest using a Fernet key derived from `.arc/arc.mkey`,
+and are never written to arc.toml or any non-secret config file.
+
+Cloud providers (Vault, AWS Secrets Manager, Azure Key Vault) implement the
+same three functions (`load`, `save_value`, `delete_value`) against their own
+backend — this module is one interchangeable implementation of that shape,
+not a hardcoded dependency of the settings layer above it.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+from pathlib import Path
+
+from cryptography.fernet import Fernet, InvalidToken
+
+
+class SecretsError(RuntimeError):
+    """Raised for any secrets-store failure (missing key, corrupt store, etc.)."""
+
+
+def _fernet_from_mkey(mkey_path: Path) -> Fernet:
+    if not mkey_path.exists():
+        raise SecretsError(
+            f"Master key not found at {mkey_path}. Run `arc init` first."
+        )
+    mkey_hex = mkey_path.read_text().strip()
+    try:
+        raw = bytes.fromhex(mkey_hex)
+    except ValueError as exc:
+        raise SecretsError(f"Master key at {mkey_path} is not valid hex.") from exc
+    if len(raw) != 32:
+        raise SecretsError(
+            f"Master key at {mkey_path} must decode to 32 bytes, got {len(raw)}."
+        )
+    fernet_key = base64.urlsafe_b64encode(raw)
+    return Fernet(fernet_key)
+
+
+def load(secrets_path: Path, mkey_path: Path) -> dict[str, str]:
+    """Decrypt and return the full secrets dict. Empty dict if store is empty/new."""
+    if not secrets_path.exists() or secrets_path.stat().st_size == 0:
+        return {}
+
+    fernet = _fernet_from_mkey(mkey_path)
+    token = secrets_path.read_bytes()
+    try:
+        plaintext = fernet.decrypt(token)
+    except InvalidToken as exc:
+        raise SecretsError(
+            f"Could not decrypt {secrets_path} — wrong master key, or the store is corrupt."
+        ) from exc
+    return json.loads(plaintext.decode("utf-8"))
+
+
+def _write(secrets_path: Path, mkey_path: Path, data: dict[str, str]) -> None:
+    fernet = _fernet_from_mkey(mkey_path)
+    plaintext = json.dumps(data, sort_keys=True).encode("utf-8")
+    token = fernet.encrypt(plaintext)
+    secrets_path.write_bytes(token)
+    secrets_path.chmod(0o600)
+
+
+def save_value(secrets_path: Path, mkey_path: Path, key: str, value: str) -> None:
+    """Set a single secret key, preserving all others already stored."""
+    data = load(secrets_path, mkey_path)
+    data[key] = value
+    _write(secrets_path, mkey_path, data)
+
+
+def delete_value(secrets_path: Path, mkey_path: Path, key: str) -> bool:
+    """Remove a single secret key. Returns True if it existed."""
+    data = load(secrets_path, mkey_path)
+    if key not in data:
+        return False
+    del data[key]
+    _write(secrets_path, mkey_path, data)
+    return True

arc/settings.py

@@ -0,0 +1,246 @@
+"""
+arc.settings
+-------------------
+Implements the single `get()` / `set()` / `delete()` surface described in the
+ARC settings design: one call site for every key, secret or not. The manager
+decides internally which store a key belongs in.
+
+Layout on disk:
+    .arc/arc.toml     -> [settings] table for plain config
+                      -> [secrets]  declared = ["key1", "key2"]   (NAMES only, never values)
+    .arc/arc.secrets  -> encrypted store holding the actual secret VALUES
+    .arc/arc.mkey     -> master key used to encrypt/decrypt arc.secrets
+
+A key is treated as secret if (a) the caller passes secret=True on `set`, or
+(b) the key already appears in [secrets].declared — so callers never have to
+remember whether a key is secret on every subsequent get().
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import tomlkit
+from tomlkit import TOMLDocument
+
+from . import secrets as secret_store
+
+REDACTED = "********"
+
+
+class SettingsError(RuntimeError):
+    pass
+
+
+class SettingsManager:
+    def __init__(self, arc_dir: Path):
+        self.arc_dir = arc_dir
+        self.toml_path = arc_dir / "arc.toml"
+        self.secrets_path = arc_dir / "arc.secrets"
+        self.mkey_path = arc_dir / "arc.mkey"
+
+        if not self.toml_path.exists():
+            raise SettingsError(
+                f"{self.toml_path} not found. Run `arc init` first."
+            )
+
+    # ------------------------------------------------------------------ #
+    # Internal helpers
+    # ------------------------------------------------------------------ #
+    def _read_toml(self) -> TOMLDocument:
+        return tomlkit.parse(self.toml_path.read_text())
+
+    def _write_toml(self, doc: TOMLDocument) -> None:
+        self.toml_path.write_text(tomlkit.dumps(doc))
+
+    def _declared_secret_keys(self, doc: TOMLDocument) -> list[str]:
+        return list(doc.get("secrets", {}).get("declared", []))
+
+    def _declare_secret_key(self, doc: TOMLDocument, key: str) -> None:
+        secrets_table = doc.setdefault("secrets", tomlkit.table())
+        declared = secrets_table.setdefault("declared", tomlkit.array())
+        if key not in declared:
+            declared.append(key)
+
+    def _undeclare_secret_key(self, doc: TOMLDocument, key: str) -> None:
+        secrets_table = doc.get("secrets")
+        if not secrets_table:
+            return
+        declared = secrets_table.get("declared")
+        if declared and key in declared:
+            declared.remove(key)
+
+    def is_secret(self, key: str) -> bool:
+        doc = self._read_toml()
+        return key in self._declared_secret_keys(doc)
+
+    # ------------------------------------------------------------------ #
+    # Public API — mirrors arc.settings.get/set/delete at runtime
+    # ------------------------------------------------------------------ #
+    def get(self, key: str, reveal: bool = False) -> str | None:
+        doc = self._read_toml()
+
+        if key in self._declared_secret_keys(doc):
+            values = secret_store.load(self.secrets_path, self.mkey_path)
+            value = values.get(key)
+            if value is None:
+                return None
+            return value if reveal else REDACTED
+
+        settings_table = doc.get("settings", {})
+        value = settings_table.get(key)
+        return str(value) if value is not None else None
+
+    def set(self, key: str, value: str, secret: bool = False) -> None:
+        doc = self._read_toml()
+
+        if secret:
+            secret_store.save_value(self.secrets_path, self.mkey_path, key, value)
+            self._declare_secret_key(doc, key)
+            # If the same key previously existed as a plain setting, remove it
+            # so there is exactly one source of truth per key.
+            settings_table = doc.get("settings")
+            if settings_table and key in settings_table:
+                del settings_table[key]
+            self._write_toml(doc)
+            return
+
+        if key in self._declared_secret_keys(doc):
+            raise SettingsError(
+                f"'{key}' is declared as a secret. Use --secret to update it, "
+                f"or delete it first if you want it to become a plain setting."
+            )
+
+        settings_table = doc.setdefault("settings", tomlkit.table())
+        settings_table[key] = value
+        self._write_toml(doc)
+
+    def delete(self, key: str) -> bool:
+        doc = self._read_toml()
+
+        if key in self._declared_secret_keys(doc):
+            existed = secret_store.delete_value(self.secrets_path, self.mkey_path, key)
+            self._undeclare_secret_key(doc, key)
+            self._write_toml(doc)
+            return existed
+
+        settings_table = doc.get("settings")
+        if settings_table and key in settings_table:
+            del settings_table[key]
+            self._write_toml(doc)
+            return True
+        return False
+
+    # ------------------------------------------------------------------ #
+    # NEW — needed by arc.boot() / plugin register(): declare a key's
+    # secret-ness up front, with no value yet (§3.5, "typically by the
+    # owning plugin"), and let boot inspect which secrets provider is
+    # configured so it can emit the local-file advisory.
+    # ------------------------------------------------------------------ #
+    def declare(self, key: str, secret: bool = False) -> None:
+        """
+        Declare a key's secret-ness without setting a value yet. Idempotent.
+        Mirrors the existing get/set collision rules: a key already declared
+        the other way must be resolved explicitly rather than silently
+        flipped.
+        """
+        doc = self._read_toml()
+        declared = key in self._declared_secret_keys(doc)
+
+        if secret:
+            if declared:
+                return
+            settings_table = doc.get("settings")
+            if settings_table and key in settings_table:
+                raise SettingsError(
+                    f"'{key}' already exists as a plain setting. Use "
+                    f"set('{key}', <value>, secret=True) to migrate its value "
+                    f"into the secret store, or delete it first."
+                )
+            self._declare_secret_key(doc, key)
+            self._write_toml(doc)
+        elif declared:
+            raise SettingsError(
+                f"'{key}' is declared as a secret; delete it first if it "
+                f"should become a plain setting."
+            )
+        # declaring a plain key that isn't already a secret is a no-op —
+        # plain keys need no declaration to be set.
+
+    def secrets_provider(self) -> str:
+        """The configured [secrets].provider — 'local_file' when unset (§3.5)."""
+        doc = self._read_toml()
+        secrets_table = doc.get("secrets", {})
+        return str(secrets_table.get("provider", "local_file"))
+
+    # ------------------------------------------------------------------ #
+    # NEW — enumeration. Every other method here answers "what's the value
+    # of THIS key", assuming the caller already knows the key exists (a
+    # plugin declares its own keys at boot). Nothing previously answered
+    # "what keys exist at all" — a real gap once something (admin's own
+    # Settings page) needs to show the whole picture rather than one
+    # already-known key. Read-only, additive, and structurally incapable
+    # of leaking a secret value: it reads [settings] directly (already
+    # plaintext on disk) but only ever lists secret NAMES from
+    # [secrets].declared, never touching secret_store.load() at all.
+    # ------------------------------------------------------------------ #
+    def list_all(self) -> dict:
+        doc = self._read_toml()
+        # tomlkit hands back its own String/Array wrapper types (it
+        # preserves formatting/whitespace for round-tripping), not plain
+        # Python str — msgspec's encoder doesn't recognize them and raises
+        # "Encoding objects of type String is unsupported". get() above
+        # already casts a single value with str(value) for this exact
+        # reason; this does the same for every value/key here.
+        settings_table = doc.get("settings", {})
+        return {
+            "settings": {str(k): str(v) for k, v in settings_table.items()},
+            "secrets": [str(k) for k in self._declared_secret_keys(doc)],
+        }
+
+
+# --------------------------------------------------------------------------- #
+# NEW — module-level runtime API for arc.boot().
+#
+# §3.5 writes this as `arc.settings.get(...)` / `arc.settings.declare(...)`:
+# the `settings` module itself is the runtime surface application code and
+# plugins use after boot, proxying to the booted kernel's project-bound
+# SettingsManager (the same class the CLI uses directly, above). Defined at
+# the very end of the file so the builtin `set` is untouched by everything
+# above it.
+# --------------------------------------------------------------------------- #
+def _bound_manager() -> SettingsManager:
+    from . import _state
+
+    kernel = _state.get_kernel()
+    if kernel is None or kernel.settings is None:
+        raise SettingsError(
+            "arc.settings is not bound to a project — call arc.boot() (from "
+            "inside an ARC project) before using arc.settings.get/set/delete/"
+            "declare. Outside the runtime, use the CLI: `arc settings ...`."
+        )
+    return kernel.settings
+
+
+def get(key: str, reveal: bool = False) -> str | None:
+    return _bound_manager().get(key, reveal=reveal)
+
+
+def set(key: str, value: str, secret: bool = False) -> None:  # noqa: A001 - deliberate API name
+    return _bound_manager().set(key, value, secret=secret)
+
+
+def delete(key: str) -> bool:
+    return _bound_manager().delete(key)
+
+
+def declare(key: str, secret: bool = False) -> None:
+    return _bound_manager().declare(key, secret=secret)
+
+
+def is_secret(key: str) -> bool:
+    return _bound_manager().is_secret(key)
+
+
+def list_all() -> dict:
+    return _bound_manager().list_all()

arc_kernel-0.1.0.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: arc-kernel
+Version: 0.1.0
+Summary: ARC kernel — capability-based Python platform
+Project-URL: Homepage, https://github.com/vignesh-ramsh/arc
+Project-URL: Repository, https://github.com/vignesh-ramsh/arc
+Author: Vignesh Ramsh
+License-Expression: MIT
+License-File: LICENSE
+Keywords: arc,capability,cli,framework,kernel
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.12
+Requires-Dist: cryptography>=42.0
+Requires-Dist: msgspec>=0.18
+Requires-Dist: rich>=13.0
+Requires-Dist: tomlkit>=0.12
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# kernel
+
+The ARC kernel — repo/project name is `kernel`; the Python package it
+provides is `arc` (flat layout, no `src/`). This is what every project's
+`arc.<capability>` namespace is ultimately built on.
+
+```
+arc/                # this repo
+├── pyproject.toml      # name = "arc-kernel" (distribution — "arc" was taken
+│                          on PyPI), packages = ["arc"]
+├── README.md
+├── LICENSE
+├── .gitignore
+└── arc/                # the actual package — `import arc`
+    ├── __init__.py
+    ├── cli.py           # the `arc` command: init, install, build, settings, plugin
+    ├── registry.py
+    ├── settings.py
+    └── secrets.py
+```
+
+## Two-tier install model (mirrors frappe-bench / bench)
+
+1. **Bootstrap globally, once** — either `pip install arc-kernel` (or
+   `pipx install arc-kernel` / `uv tool install arc-kernel`, both preferred
+   over a bare `pip install` for a CLI tool) from PyPI, or
+   `uv tool install --editable .` from a local clone of this repo if you're
+   working on the kernel itself. Either way you get the `arc` command
+   anywhere on your machine.
+2. **Per project** — `arc init` clones THIS repo into `<project>/arc/` and wires
+   up a uv workspace. From then on, use `<project>/.venv/bin/arc` for project
+   commands — that copy is pinned to the exact commit this project was built
+   against, independent of the global bootstrap CLI's version.
+
+Note: inside a scaffolded project you'll see `project/arc/arc/` — the outer
+`arc/` is this project's kernel *slot* (a workspace member, named the way
+`apps/frappe` names its slot in a bench); the inner `arc/` is the actual
+Python package. Two different things, same name for a real reason — not
+duplication.
+
+## Commands
+
+```bash
+arc init [project_name] --kernel-repo <git-url-or-path> [--kernel-branch main] [--env dev]
+arc install <git-url> [--branch BRANCH] [--name NAME]
+arc build [-p/--plugin NAME] [--no-lock]
+arc settings get <key> [--reveal]
+arc settings set <key> <value> [--secret]
+arc settings delete <key>
+arc plugin list
+arc plugin enable <name>
+arc plugin disable <name>
+```
+
+`ARC_KERNEL_REPO` env var can be set once so `--kernel-repo` doesn't need to
+be typed on every `arc init`.
+
+## Plugin manifest format
+
+Every plugin repo has, at its root:
+
+```toml
+# plugin.toml — ARC-specific metadata only
+[plugin]
+name = "psqldb"
+version = "0.1.0"
+capability = "psqldb"          # exported as arc.<capability> at boot
+requires = []
+optional_requires = ["redix"]
+```
+
+```toml
+# pyproject.toml — standard Python packaging; real dependencies live HERE
+[project]
+name = "psqldb"
+dependencies = ["asyncpg>=0.29"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+```
+
+Following this same kernel's convention, plugin packages should also use a
+flat layout (`psqldb/psqldb/__init__.py` inside the plugin's own repo, not
+`psqldb/src/psqldb/`) — same reasoning, same fix, applied consistently.

arc_kernel-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+arc/__init__.py,sha256=bLJ90yTygTLkan9eK4wWqVmcre6y0RF02aVjVLEAgPQ,2009
+arc/_state.py,sha256=Qfs5AHxcnzo3s95gUJdIpmgaMwwHDSDzVxqkCEGsc50,813
+arc/cli.py,sha256=kqyma1MXk3hagOID6yuiOekbUj1d4WrTnN_joeK4kco,35184
+arc/codec.py,sha256=Y_Ezx-5PKg3PcChQllT6ZKddk0qaIF6nCBiGBz4LNzo,2939
+arc/doctor.py,sha256=9J3NcvqCOZvYu8JVqL6IYosov_lhKPkL2Z7G9479QDA,3358
+arc/health.py,sha256=8MxUvICTLzQD5l7DuSBy3xx4GzDSZHNURFAd5UvBDJY,1921
+arc/healthcmd.py,sha256=syowduYxXvoXi0XkuXws_UwKBWPraLQmJnRGaIZGiRA,2772
+arc/kernel.py,sha256=ylD5ncnlFGgj6e4-1Alf1W3VYZVRdI9O3RixekHARwQ,12006
+arc/plugin_cli.py,sha256=B__phnQF2_HtOQ-MF-c30uRk0rm0rvg-4p00fwJTlx4,4867
+arc/registry.py,sha256=Q6rREkaPwnP8t2KwGKiFOjxH9oxlrv8iiCFbdR1FLN4,5949
+arc/resolver.py,sha256=CglliHX3EUQj57zhxergUoomcvv3GPhAXn4wD7c8VDg,13884
+arc/runtime.py,sha256=VLjKJGtxk0SoFB9wC7qYz2Jcz35U_A0vG4HMKwcn_Pc,7322
+arc/secrets.py,sha256=5As5o8nXBxln6jdktBEDuE_2W4tfoYRk96N6wMJQ2ys,2915
+arc/settings.py,sha256=LHbXAdzs_BxOfvzubUmcVluSl81V4S4NixVcIlUiC3U,9976
+arc_kernel-0.1.0.dist-info/METADATA,sha256=C5l78s2gvUF-FqipcTdYAWfBm1no3j86qlQLIe7INn4,3945
+arc_kernel-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+arc_kernel-0.1.0.dist-info/entry_points.txt,sha256=fZYe2b6BdwlzsXOPCjIZHVReCO5kmAeLWnz7hYX-xFo,36
+arc_kernel-0.1.0.dist-info/licenses/LICENSE,sha256=fsl3ih-5C8nclkwJo9UKUjDWVIZzkupjrNPudz8Ghrk,1070
+arc_kernel-0.1.0.dist-info/RECORD,,

arc_kernel-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

arc_kernel-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+arc = arc.cli:app

arc_kernel-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vignesh Ramsh
+
+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.