claw-code 0.2.0__py3-none-any.whl

src/execution_registry.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .commands import PORTED_COMMANDS, execute_command
+from .tools import PORTED_TOOLS, execute_tool
+
+
+@dataclass(frozen=True)
+class MirroredCommand:
+    name: str
+    source_hint: str
+
+    def execute(self, prompt: str) -> str:
+        return execute_command(self.name, prompt).message
+
+
+@dataclass(frozen=True)
+class MirroredTool:
+    name: str
+    source_hint: str
+
+    def execute(self, payload: str) -> str:
+        return execute_tool(self.name, payload).message
+
+
+@dataclass(frozen=True)
+class ExecutionRegistry:
+    commands: tuple[MirroredCommand, ...]
+    tools: tuple[MirroredTool, ...]
+
+    def command(self, name: str) -> MirroredCommand | None:
+        lowered = name.lower()
+        for command in self.commands:
+            if command.name.lower() == lowered:
+                return command
+        return None
+
+    def tool(self, name: str) -> MirroredTool | None:
+        lowered = name.lower()
+        for tool in self.tools:
+            if tool.name.lower() == lowered:
+                return tool
+        return None
+
+
+def build_execution_registry() -> ExecutionRegistry:
+    return ExecutionRegistry(
+        commands=tuple(MirroredCommand(module.name, module.source_hint) for module in PORTED_COMMANDS),
+        tools=tuple(MirroredTool(module.name, module.source_hint) for module in PORTED_TOOLS),
+    )

src/history.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class HistoryEvent:
+    title: str
+    detail: str
+
+
+@dataclass
+class HistoryLog:
+    events: list[HistoryEvent] = field(default_factory=list)
+
+    def add(self, title: str, detail: str) -> None:
+        self.events.append(HistoryEvent(title=title, detail=detail))
+
+    def as_markdown(self) -> str:
+        lines = ['# Session History', '']
+        lines.extend(f'- {event.title}: {event.detail}' for event in self.events)
+        return '\n'.join(lines)

src/hooks/__init__.py

@@ -0,0 +1,16 @@
+"""Python package placeholder for the archived `hooks` subsystem."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'hooks.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
+
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
+PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
+
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/init_wizard.py

@@ -0,0 +1,238 @@
+"""
+First-run wizard for Claw Code initialization.
+Detects Ollama, RAM, pulls model, writes config.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+from .config import load_config
+from .services.ollama_adapter import OllamaAdapter
+from .services.ollama_setup import (
+    check_ollama_installed,
+    ensure_config_exists,
+    pull_model,
+    validate_setup,
+    print_validation_report,
+)
+from .model_detection import get_available_models, detect_best_model
+
+
+logger = logging.getLogger(__name__)
+
+
+def print_banner():
+    """Print welcome banner"""
+    print("\n" + "=" * 70)
+    print(" 🚀 Welcome to Claw Code - Local Claude Alternative")
+    print("=" * 70)
+    print("\nThis wizard will help you get started in under 3 minutes.\n")
+
+
+def step_1_check_ollama():
+    """Step 1: Verify Ollama installation"""
+    print("📋 Step 1: Checking Ollama installation...")
+    
+    if check_ollama_installed():
+        print("✓ Ollama CLI found\n")
+        return True
+    else:
+        print("✗ Ollama not installed")
+        print("\n→ Download from: https://ollama.ai")
+        print("→ Then run: claw-code init\n")
+        return False
+
+
+def step_2_detect_system():
+    """Step 2: Detect system VRAM"""
+    print("📋 Step 2: Detecting system resources...")
+    
+    vram_gb = OllamaAdapter.get_available_vram_gb()
+    print(f"✓ Detected: {vram_gb:.1f}GB VRAM\n")
+    
+    return vram_gb
+
+
+def step_3_recommend_model(vram_gb: float):
+    """Step 3: Recommend model tier"""
+    print("📋 Step 3: Recommending model for your system...")
+    
+    from .services.ollama_adapter import MODEL_TIERS
+    
+    for tier in MODEL_TIERS:
+        if tier.vram_min_gb <= vram_gb <= tier.vram_max_gb:
+            print(f"✓ Recommended: {tier.name}")
+            print(f"  VRAM: {tier.vram_required_gb}GB | Speed: {tier.tokens_per_sec_estimate} tok/s")
+            print(f"  Use: {tier.use_case}\n")
+            return tier.name
+    
+    # Fallback
+    print("✓ Using conservative tier: phi4-mini\n")
+    return "phi4-mini"
+
+
+def step_4_check_models():
+    """Step 4: Check if model is already available"""
+    print("📋 Step 4: Checking for available models...")
+    
+    try:
+        available = get_available_models()
+        if available:
+            print(f"✓ Found {len(available)} model(s) installed:")
+            for model in available:
+                print(f"  - {model}")
+            print()
+            return available
+        else:
+            print("⚠ No models installed yet\n")
+            return None
+    except Exception as e:
+        logger.warning(f"Could not list models: {e}")
+        return None
+
+
+def step_5_pull_model(recommended_model: str, available_models: list[str] | None):
+    """Step 5: Pull model if needed"""
+    print("📋 Step 5: Model setup...")
+    
+    # Check if recommended is already available
+    if available_models and recommended_model in available_models:
+        print(f"✓ {recommended_model} already installed\n")
+        return recommended_model
+    
+    print(f"→ Need to download {recommended_model} (~6GB)")
+    print("→ This might take a few minutes...\n")
+    
+    response = input("Pull now? (y/n): ").strip().lower()
+    
+    if response == "y":
+        print()
+        if pull_model(recommended_model):
+            print(f"\n✓ {recommended_model} ready\n")
+            return recommended_model
+        else:
+            print(f"\n✗ Failed to pull {recommended_model}")
+            print("→ Try manually: ollama pull " + recommended_model)
+            return None
+    else:
+        print(f"\nℹ To pull manually: ollama pull {recommended_model}\n")
+        return None
+
+
+def step_6_start_ollama():
+    """Step 6: Instruct to start Ollama if not running"""
+    print("📋 Step 6: Checking if Ollama is running...")
+    
+    try:
+        OllamaAdapter()
+        print("✓ Ollama server is running\n")
+        return True
+    except RuntimeError:
+        print("⚠ Ollama server not running")
+        print("\n→ In another terminal, run: ollama serve\n")
+        return False
+
+
+def step_7_create_config():
+    """Step 7: Create configuration file"""
+    print("📋 Step 7: Creating configuration...")
+    
+    config_path = ensure_config_exists()
+    print(f"✓ Config created: {config_path}\n")
+    
+    return config_path
+
+
+def step_8_validate():
+    """Step 8: Validate complete setup"""
+    print("📋 Step 8: Validating setup...")
+    
+    report = validate_setup()
+    
+    if report["ollama_running"] and report["model_available"]:
+        print(f"✓ Everything ready! Model: {report['model_available']}\n")
+        return True
+    else:
+        if not report["ollama_running"]:
+            print("⚠ Ollama server not detected (start with: ollama serve)")
+        if not report["model_available"]:
+            print("⚠ No model detected (pull with: ollama pull qwen2.5-coder:7b)")
+        print()
+        return False
+
+
+def print_next_steps():
+    """Print what to do next"""
+    print("=" * 70)
+    print(" 🎉 Setup Complete!")
+    print("=" * 70 + "\n")
+    
+    print("Next steps:\n")
+    print("1. Make sure Ollama is running (in another terminal):")
+    print("   ollama serve\n")
+    
+    print("2. Start Claw Code interactive REPL:")
+    print("   claw-code\n")
+    
+    print("3. Try some commands:")
+    print("   > write a Python quicksort")
+    print("   > explain this function")
+    print("   > help\n")
+    
+    print("Commands:")
+    print("  /clear       — Clear conversation history")
+    print("  /exit        — Exit the REPL")
+    print("  /session     — Show session info")
+    print("  /help        — Show help\n")
+
+
+def run_init_wizard() -> bool:
+    """Run the complete initialization wizard"""
+    print_banner()
+    
+    # Step 1: Check Ollama
+    if not step_1_check_ollama():
+        return False
+    
+    # Step 2: Detect system
+    vram_gb = step_2_detect_system()
+    
+    # Step 3: Recommend model
+    recommended = step_3_recommend_model(vram_gb)
+    
+    # Step 4: Check available models
+    available = step_4_check_models()
+    
+    # Step 5: Pull model if needed
+    model = step_5_pull_model(recommended, available)
+    
+    # Step 6: Check if Ollama is running
+    ollama_running = step_6_start_ollama()
+    
+    # Step 7: Create config
+    step_7_create_config()
+    
+    # Step 8: Validate
+    ready = step_8_validate()
+    
+    # Next steps
+    print_next_steps()
+    
+    if not ollama_running:
+        print("⚠ Please start Ollama (ollama serve) in another terminal,")
+        print("  then run: claw-code\n")
+    elif not model:
+        print("⚠ Please pull a model manually, then run: claw-code\n")
+    else:
+        print("✓ Ready to go! Run: claw-code\n")
+    
+    return ready
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    success = run_init_wizard()
+    sys.exit(0 if success else 1)

src/ink.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+
+def render_markdown_panel(text: str) -> str:
+    border = '=' * 40
+    return f"{border}\n{text}\n{border}"

src/interactiveHelpers.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+
+def bulletize(items: list[str]) -> str:
+    return '\n'.join(f'- {item}' for item in items)

src/keybindings/__init__.py

@@ -0,0 +1,16 @@
+"""Python package placeholder for the archived `keybindings` subsystem."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'keybindings.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
+
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
+PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
+
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/main.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import argparse
+
+from .bootstrap_graph import build_bootstrap_graph
+from .command_graph import build_command_graph
+from .commands import execute_command, get_command, get_commands, render_command_index
+from .direct_modes import run_deep_link, run_direct_connect
+from .init_wizard import run_init_wizard
+from .parity_audit import run_parity_audit
+from .permissions import ToolPermissionContext
+from .port_manifest import build_port_manifest
+from .query_engine import QueryEnginePort
+from .remote_runtime import run_remote_mode, run_ssh_mode, run_teleport_mode
+from .repl import run_repl
+from .runtime import PortRuntime
+from .session_store import load_session
+from .setup import run_setup
+from .tool_pool import assemble_tool_pool
+from .tools import execute_tool, get_tool, get_tools, render_tool_index
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description='Claw Code - Local Claude AI CLI powered by Ollama')
+    
+    # Top-level flags
+    parser.add_argument('--version', action='store_true', help='show version and exit')
+    parser.add_argument('--resume', type=str, help='resume a previous session by ID')
+    
+    subparsers = parser.add_subparsers(dest='command', required=False)
+    
+    # Initialization wizard
+    subparsers.add_parser('init', help='first-run setup wizard (checks Ollama, pulls model)')
+    
+    # Interactive REPL (implicit if no command)
+    
+    # Existing commands
+    subparsers.add_parser('summary', help='render a Markdown summary of the Python porting workspace')
+    subparsers.add_parser('manifest', help='print the current Python workspace manifest')
+    subparsers.add_parser('parity-audit', help='compare the Python workspace against the local ignored TypeScript archive when available')
+    subparsers.add_parser('setup-report', help='render the startup/prefetch setup report')
+    subparsers.add_parser('command-graph', help='show command graph segmentation')
+    subparsers.add_parser('tool-pool', help='show assembled tool pool with default settings')
+    subparsers.add_parser('bootstrap-graph', help='show the mirrored bootstrap/runtime graph stages')
+    list_parser = subparsers.add_parser('subsystems', help='list the current Python modules in the workspace')
+    list_parser.add_argument('--limit', type=int, default=32)
+
+    commands_parser = subparsers.add_parser('commands', help='list mirrored command entries from the archived snapshot')
+    commands_parser.add_argument('--limit', type=int, default=20)
+    commands_parser.add_argument('--query')
+    commands_parser.add_argument('--no-plugin-commands', action='store_true')
+    commands_parser.add_argument('--no-skill-commands', action='store_true')
+
+    tools_parser = subparsers.add_parser('tools', help='list mirrored tool entries from the archived snapshot')
+    tools_parser.add_argument('--limit', type=int, default=20)
+    tools_parser.add_argument('--query')
+    tools_parser.add_argument('--simple-mode', action='store_true')
+    tools_parser.add_argument('--no-mcp', action='store_true')
+    tools_parser.add_argument('--deny-tool', action='append', default=[])
+    tools_parser.add_argument('--deny-prefix', action='append', default=[])
+
+    route_parser = subparsers.add_parser('route', help='route a prompt across mirrored command/tool inventories')
+    route_parser.add_argument('prompt')
+    route_parser.add_argument('--limit', type=int, default=5)
+
+    bootstrap_parser = subparsers.add_parser('bootstrap', help='build a runtime-style session report from the mirrored inventories')
+    bootstrap_parser.add_argument('prompt')
+    bootstrap_parser.add_argument('--limit', type=int, default=5)
+
+    loop_parser = subparsers.add_parser('turn-loop', help='run a small stateful turn loop for the mirrored runtime')
+    loop_parser.add_argument('prompt')
+    loop_parser.add_argument('--limit', type=int, default=5)
+    loop_parser.add_argument('--max-turns', type=int, default=3)
+    loop_parser.add_argument('--structured-output', action='store_true')
+    loop_parser.add_argument('--stream', action='store_true', help='stream output in real-time from Ollama')
+
+    flush_parser = subparsers.add_parser('flush-transcript', help='persist and flush a temporary session transcript')
+    flush_parser.add_argument('prompt')
+
+    load_session_parser = subparsers.add_parser('load-session', help='load a previously persisted session')
+    load_session_parser.add_argument('session_id')
+
+    remote_parser = subparsers.add_parser('remote-mode', help='simulate remote-control runtime branching')
+    remote_parser.add_argument('target')
+    ssh_parser = subparsers.add_parser('ssh-mode', help='simulate SSH runtime branching')
+    ssh_parser.add_argument('target')
+    teleport_parser = subparsers.add_parser('teleport-mode', help='simulate teleport runtime branching')
+    teleport_parser.add_argument('target')
+    direct_parser = subparsers.add_parser('direct-connect-mode', help='simulate direct-connect runtime branching')
+    direct_parser.add_argument('target')
+    deep_link_parser = subparsers.add_parser('deep-link-mode', help='simulate deep-link runtime branching')
+    deep_link_parser.add_argument('target')
+
+    show_command = subparsers.add_parser('show-command', help='show one mirrored command entry by exact name')
+    show_command.add_argument('name')
+    show_tool = subparsers.add_parser('show-tool', help='show one mirrored tool entry by exact name')
+    show_tool.add_argument('name')
+
+    exec_command_parser = subparsers.add_parser('exec-command', help='execute a mirrored command shim by exact name')
+    exec_command_parser.add_argument('name')
+    exec_command_parser.add_argument('prompt')
+
+    exec_tool_parser = subparsers.add_parser('exec-tool', help='execute a mirrored tool shim by exact name')
+    exec_tool_parser.add_argument('name')
+    exec_tool_parser.add_argument('payload')
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    
+    # Handle --version
+    if args.version:
+        print("claw-code v0.1.0 (Phase 1)")
+        return 0
+    
+    # Handle init command
+    if args.command == 'init':
+        success = run_init_wizard()
+        return 0 if success else 1
+    
+    # Handle --resume flag
+    if args.resume:
+        print(f"Resuming session {args.resume}...")
+        try:
+            engine = QueryEnginePort.from_saved_session(args.resume)
+            print(f"Loaded {len(engine.mutable_messages)} messages from session")
+            # TODO: Drop into REPL with loaded session
+            print("⚠ Full session resumption coming in Phase 2.5")
+            return 0
+        except Exception as e:
+            print(f"✗ Failed to load session: {e}")
+            return 1
+    
+    # Default to REPL if no command
+    if not args.command:
+        run_repl()
+        return 0
+    
+    # Original command handling below
+    manifest = build_port_manifest()
+    if args.command == 'summary':
+        print(QueryEnginePort(manifest).render_summary())
+        return 0
+    if args.command == 'manifest':
+        print(manifest.to_markdown())
+        return 0
+    if args.command == 'parity-audit':
+        print(run_parity_audit().to_markdown())
+        return 0
+    if args.command == 'setup-report':
+        print(run_setup().as_markdown())
+        return 0
+    if args.command == 'command-graph':
+        print(build_command_graph().as_markdown())
+        return 0
+    if args.command == 'tool-pool':
+        print(assemble_tool_pool().as_markdown())
+        return 0
+    if args.command == 'bootstrap-graph':
+        print(build_bootstrap_graph().as_markdown())
+        return 0
+    if args.command == 'subsystems':
+        for subsystem in manifest.top_level_modules[: args.limit]:
+            print(f'{subsystem.name}\t{subsystem.file_count}\t{subsystem.notes}')
+        return 0
+    if args.command == 'commands':
+        if args.query:
+            print(render_command_index(limit=args.limit, query=args.query))
+        else:
+            commands = get_commands(include_plugin_commands=not args.no_plugin_commands, include_skill_commands=not args.no_skill_commands)
+            output_lines = [f'Command entries: {len(commands)}', '']
+            output_lines.extend(f'- {module.name} — {module.source_hint}' for module in commands[: args.limit])
+            print('\n'.join(output_lines))
+        return 0
+    if args.command == 'tools':
+        if args.query:
+            print(render_tool_index(limit=args.limit, query=args.query))
+        else:
+            permission_context = ToolPermissionContext.from_iterables(args.deny_tool, args.deny_prefix)
+            tools = get_tools(simple_mode=args.simple_mode, include_mcp=not args.no_mcp, permission_context=permission_context)
+            output_lines = [f'Tool entries: {len(tools)}', '']
+            output_lines.extend(f'- {module.name} — {module.source_hint}' for module in tools[: args.limit])
+            print('\n'.join(output_lines))
+        return 0
+    if args.command == 'route':
+        matches = PortRuntime().route_prompt(args.prompt, limit=args.limit)
+        if not matches:
+            print('No mirrored command/tool matches found.')
+            return 0
+        for match in matches:
+            print(f'{match.kind}\t{match.name}\t{match.score}\t{match.source_hint}')
+        return 0
+    if args.command == 'bootstrap':
+        print(PortRuntime().bootstrap_session(args.prompt, limit=args.limit).as_markdown())
+        return 0
+    if args.command == 'turn-loop':
+        if hasattr(args, 'stream') and args.stream:
+            # Stream mode: real-time output
+            runtime = PortRuntime()
+            for event in runtime.stream_turn_loop(args.prompt, limit=args.limit, max_turns=args.max_turns, structured_output=args.structured_output):
+                if event['type'] == 'message_delta':
+                    print(event['text'], end='', flush=True)
+                elif event['type'] == 'message_stop':
+                    print(f"\n\n[stop_reason={event['stop_reason']}]")
+        else:
+            # Buffered mode: collect and display
+            results = PortRuntime().run_turn_loop(args.prompt, limit=args.limit, max_turns=args.max_turns, structured_output=args.structured_output)
+            for idx, result in enumerate(results, start=1):
+                print(f'## Turn {idx}')
+                print(result.output)
+                print(f'stop_reason={result.stop_reason}')
+        return 0
+    if args.command == 'flush-transcript':
+        engine = QueryEnginePort.from_workspace()
+        engine.submit_message(args.prompt)
+        path = engine.persist_session()
+        print(path)
+        print(f'flushed={engine.transcript_store.flushed}')
+        return 0
+    if args.command == 'load-session':
+        session = load_session(args.session_id)
+        print(f'{session.session_id}\n{len(session.messages)} messages\nin={session.input_tokens} out={session.output_tokens}')
+        return 0
+    if args.command == 'remote-mode':
+        print(run_remote_mode(args.target).as_text())
+        return 0
+    if args.command == 'ssh-mode':
+        print(run_ssh_mode(args.target).as_text())
+        return 0
+    if args.command == 'teleport-mode':
+        print(run_teleport_mode(args.target).as_text())
+        return 0
+    if args.command == 'direct-connect-mode':
+        print(run_direct_connect(args.target).as_text())
+        return 0
+    if args.command == 'deep-link-mode':
+        print(run_deep_link(args.target).as_text())
+        return 0
+    if args.command == 'show-command':
+        module = get_command(args.name)
+        if module is None:
+            print(f'Command not found: {args.name}')
+            return 1
+        print('\n'.join([module.name, module.source_hint, module.responsibility]))
+        return 0
+    if args.command == 'show-tool':
+        module = get_tool(args.name)
+        if module is None:
+            print(f'Tool not found: {args.name}')
+            return 1
+        print('\n'.join([module.name, module.source_hint, module.responsibility]))
+        return 0
+    if args.command == 'exec-command':
+        result = execute_command(args.name, args.prompt)
+        print(result.message)
+        return 0 if result.handled else 1
+    if args.command == 'exec-tool':
+        result = execute_tool(args.name, args.payload)
+        print(result.message)
+        return 0 if result.handled else 1
+    parser.error(f'unknown command: {args.command}')
+    return 2
+
+
+def cli_entry() -> None:
+    """Entry point for pip-installed 'claw-code' command"""
+    import sys
+    sys.exit(main())
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

src/memdir/__init__.py

@@ -0,0 +1,16 @@
+"""Python package placeholder for the archived `memdir` subsystem."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'memdir.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
+
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
+PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
+
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/migrations/__init__.py

@@ -0,0 +1,16 @@
+"""Python package placeholder for the archived `migrations` subsystem."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'migrations.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
+
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
+PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
+
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']