chipfoundry-cli 2.4.10__tar.gz → 2.5.1__tar.gz

{chipfoundry_cli-2.4.10 → chipfoundry_cli-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chipfoundry-cli
-Version: 2.4.10
+Version: 2.5.1
 Summary: CLI tool to automate ChipFoundry project submission to SFTP server
 Home-page: https://chipfoundry.io
 License: Apache-2.0
@@ -427,13 +427,18 @@ cf harden [MACRO] [OPTIONS]
 
 **Key Options:**
 - `--list` or no argument: List all available macros
+- `--list-from-steps`: List valid LibreLane step names for `--from` for a specific macro
 - `MACRO`: Name of macro to harden (e.g., `user_proj_example`, `user_project_wrapper`)
 - `--project-root`: Specify project directory
-- `--tag`: Custom run tag (defaults to timestamp)
+- `--tag`: Run tag. Without `--from`, existing tag is overwritten; with `--from`, resumes that tag
+- `--from`: Start hardening from a specific LibreLane step (e.g., `OpenROAD.DetailedRouting`)
+- `--tag` + `--from`: Resume from that step using the existing run state under the specified tag
+- `--from` without `--tag`: Resume from that step using the latest existing run tag for the macro
+- `--open-in-openroad`: Open an existing run in OpenROAD GUI (uses latest run if `--tag` omitted)
+- `--open-in-klayout`: Open an existing run in KLayout GUI (uses latest run if `--tag` omitted)
 - `--pdk`: PDK to use (default: sky130A)
 - `--use-nix`: Force use of Nix (fails if Nix not available)
 - `--use-docker`: Force use of Docker (fails if Docker not available)
-- `--dry-run`: Show configuration without running
 
 **Examples:**
 ```bash
@@ -446,8 +451,22 @@ cf harden user_proj_example
 # Harden with custom tag and PDK
 cf harden user_proj_example --tag my_run --pdk sky130B
 
-# Preview hardening configuration
-cf harden user_proj_example --dry-run
+# Resume flow from a specific LibreLane step
+cf harden user_proj_example --tag test2 --from OpenROAD.DetailedRouting
+
+# Resume from latest existing run tag automatically
+cf harden user_proj_example --from OpenROAD.DetailedRouting
+
+# Show exact valid --from step names for a macro
+cf harden user_proj_example --list-from-steps
+
+# Open GUI for a specific run tag
+cf harden user_proj_example --tag test2 --open-in-openroad
+cf harden user_proj_example --tag test2 --open-in-klayout
+
+# Open GUI for latest existing run tag automatically
+cf harden user_proj_example --open-in-openroad
+
 ```
 
 **Workflow:**

{chipfoundry_cli-2.4.10 → chipfoundry_cli-2.5.1}/README.md

@@ -401,13 +401,18 @@ cf harden [MACRO] [OPTIONS]
 
 **Key Options:**
 - `--list` or no argument: List all available macros
+- `--list-from-steps`: List valid LibreLane step names for `--from` for a specific macro
 - `MACRO`: Name of macro to harden (e.g., `user_proj_example`, `user_project_wrapper`)
 - `--project-root`: Specify project directory
-- `--tag`: Custom run tag (defaults to timestamp)
+- `--tag`: Run tag. Without `--from`, existing tag is overwritten; with `--from`, resumes that tag
+- `--from`: Start hardening from a specific LibreLane step (e.g., `OpenROAD.DetailedRouting`)
+- `--tag` + `--from`: Resume from that step using the existing run state under the specified tag
+- `--from` without `--tag`: Resume from that step using the latest existing run tag for the macro
+- `--open-in-openroad`: Open an existing run in OpenROAD GUI (uses latest run if `--tag` omitted)
+- `--open-in-klayout`: Open an existing run in KLayout GUI (uses latest run if `--tag` omitted)
 - `--pdk`: PDK to use (default: sky130A)
 - `--use-nix`: Force use of Nix (fails if Nix not available)
 - `--use-docker`: Force use of Docker (fails if Docker not available)
-- `--dry-run`: Show configuration without running
 
 **Examples:**
 ```bash
@@ -420,8 +425,22 @@ cf harden user_proj_example
 # Harden with custom tag and PDK
 cf harden user_proj_example --tag my_run --pdk sky130B
 
-# Preview hardening configuration
-cf harden user_proj_example --dry-run
+# Resume flow from a specific LibreLane step
+cf harden user_proj_example --tag test2 --from OpenROAD.DetailedRouting
+
+# Resume from latest existing run tag automatically
+cf harden user_proj_example --from OpenROAD.DetailedRouting
+
+# Show exact valid --from step names for a macro
+cf harden user_proj_example --list-from-steps
+
+# Open GUI for a specific run tag
+cf harden user_proj_example --tag test2 --open-in-openroad
+cf harden user_proj_example --tag test2 --open-in-klayout
+
+# Open GUI for latest existing run tag automatically
+cf harden user_proj_example --open-in-openroad
+
 ```
 
 **Workflow:**

{chipfoundry_cli-2.4.10 → chipfoundry_cli-2.5.1}/chipfoundry_cli/main.py

@@ -28,6 +28,7 @@ import subprocess
 import sys
 import shutil
 import signal
+import difflib
 
 # Textual imports for GPIO grid UI
 from textual.app import App, ComposeResult
@@ -41,6 +42,42 @@ DEFAULT_SFTP_HOST = 'sftp.chipfoundry.io'
 
 console = Console()
 
+class CategorizedCommand(click.Command):
+    """Click command with categorized help sections for options."""
+
+    def __init__(self, *args, option_categories=None, **kwargs):
+        self.option_categories = option_categories or []
+        super().__init__(*args, **kwargs)
+
+    def format_options(self, ctx, formatter):
+        options = {}
+        for param in self.get_params(ctx):
+            if not isinstance(param, click.Option):
+                continue
+            # Keep built-in --help available but omit it from custom sections.
+            if param.name == "help":
+                continue
+            record = param.get_help_record(ctx)
+            if record:
+                # Make option names easier to scan in help output.
+                options[param.name] = (click.style(record[0], fg="cyan"), record[1])
+
+        rendered = set()
+        for title, option_names in self.option_categories:
+            rows = []
+            for opt_name in option_names:
+                if opt_name in options:
+                    rows.append(options[opt_name])
+                    rendered.add(opt_name)
+            if rows:
+                with formatter.section(click.style(title, fg="green", bold=True)):
+                    formatter.write_dl(rows)
+
+        remaining_rows = [row for name, row in options.items() if name not in rendered]
+        if remaining_rows:
+            with formatter.section(click.style("Other Options", fg="green", bold=True)):
+                formatter.write_dl(remaining_rows)
+
 def get_git_tag(repo_path):
     """Get the current git tag/branch of a repository."""
     try:
@@ -3659,23 +3696,29 @@ def setup(project_root, repo_owner, repo_name, branch, pdk, caravel_lite,
         else:
             console.print("[bold green]Setup complete![/bold green]")
     
-@main.command('harden')
+@main.command(
+    'harden',
+    cls=CategorizedCommand,
+    option_categories=[
+        ("Design Selection", ["project_root", "list_designs", "list_from_steps"]),
+        ("Run Controls", ["tag", "from_step"]),
+        ("GUI Modes", ["open_in_openroad", "open_in_klayout"]),
+        ("Execution Backend", ["pdk", "use_nix", "use_docker"]),
+    ],
+)
 @click.argument('macro', required=False)
 @click.option('--project-root', type=click.Path(exists=True, file_okay=False), help='Path to the project directory (defaults to current directory)')
 @click.option('--list', 'list_designs', is_flag=True, help='List all available macros')
-@click.option('--tag', help='Custom run tag (defaults to timestamp)')
+@click.option('--list-from-steps', is_flag=True, help='List valid LibreLane step names for --from (requires MACRO)')
+@click.option('--tag', help='Run tag. Without --from, existing tag is overwritten; with --from, resumes that tag')
+@click.option('--from', 'from_step', help='Start hardening from a specific LibreLane step (uses latest run tag if --tag is omitted)')
+@click.option('--open-in-openroad', is_flag=True, help='Open an existing run in the OpenROAD GUI')
+@click.option('--open-in-klayout', is_flag=True, help='Open an existing run in the KLayout GUI')
 @click.option('--pdk', help='PDK to use (defaults to sky130A)')
 @click.option('--use-nix', is_flag=True, help='Force use of Nix (fails if Nix not available)')
 @click.option('--use-docker', is_flag=True, help='Force use of Docker (fails if Docker not available)')
-@click.option('--dry-run', is_flag=True, help='Show the configuration without running')
-def harden(macro, project_root, list_designs, tag, pdk, use_nix, use_docker, dry_run):
-    """Harden a macro using LibreLane (OpenLane 2).
-    
-    Examples:
-        cf harden user_proj_example   # Harden a specific macro
-        cf harden user_project_wrapper
-        cf harden --list              # List available macros
-    """
+def harden(macro, project_root, list_designs, list_from_steps, tag, from_step, open_in_openroad, open_in_klayout, pdk, use_nix, use_docker):
+    """Harden a macro using LibreLane (OpenLane 2)."""
     from datetime import datetime
     
     # If .cf/project.json exists in cwd, use it as default project_root
@@ -3689,7 +3732,7 @@ def harden(macro, project_root, list_designs, tag, pdk, use_nix, use_docker, dry
     
     # Check if project is initialized (skip check for --list or when no macro specified, allow graceful return)
     if not list_designs and macro:
-        if not check_project_initialized(project_root_path, 'harden', dry_run=dry_run, allow_graceful=True):
+        if not check_project_initialized(project_root_path, 'harden', allow_graceful=True):
             console.print(f"[red]✗[/red] Project not initialized. Please run 'cf init' first.")
             console.print("[yellow]Run 'cf setup' first to install OpenLane[/yellow]")
             return
@@ -3702,9 +3745,26 @@ def harden(macro, project_root, list_designs, tag, pdk, use_nix, use_docker, dry
         console.print("[yellow]Run 'cf setup' first to install OpenLane[/yellow]")
         return
     
+    if list_from_steps and not macro:
+        console.print("[red]✗[/red] --list-from-steps requires a macro name")
+        console.print("[yellow]Example:[/yellow] cf harden user_proj_example --list-from-steps")
+        return
+
+    gui_mode_count = int(open_in_openroad) + int(open_in_klayout)
+    if gui_mode_count > 1:
+        console.print("[red]✗[/red] Use only one GUI flag: --open-in-openroad or --open-in-klayout")
+        return
+    if gui_mode_count and from_step:
+        console.print("[red]✗[/red] --from cannot be combined with GUI modes")
+        console.print("[yellow]Use --tag to select which run to open, or omit --tag to use latest run[/yellow]")
+        return
+    if gui_mode_count and list_from_steps:
+        console.print("[red]✗[/red] --list-from-steps cannot be combined with GUI modes")
+        return
+
     # If no macro specified, show prompt with available macros
-    no_macro_specified = not macro and not list_designs
-    if not macro:
+    no_macro_specified = not macro and not list_designs and not list_from_steps
+    if not macro and not list_from_steps:
         list_designs = True
     
     # List designs if requested (or if no macro specified)
@@ -3753,6 +3813,89 @@ def harden(macro, project_root, list_designs, tag, pdk, use_nix, use_docker, dry
         console.print("[red]✗[/red] LibreLane not installed")
         console.print("[yellow]Run 'cf setup --only-openlane' to install LibreLane[/yellow]")
         raise click.Abort()
+
+    # Resolve valid step names for this macro's selected flow using LibreLane itself.
+    def get_valid_from_steps(librelane_python, macro_config, working_dir):
+        script = (
+            "import json, sys\n"
+            "from librelane.config import Config\n"
+            "from librelane.flows import Flow, SequentialFlow\n"
+            "cfg = sys.argv[1]\n"
+            "target = Flow.factory.get('Classic')\n"
+            "meta = Config.get_meta(cfg)\n"
+            "if meta:\n"
+            "    if isinstance(meta.flow, str):\n"
+            "        found = Flow.factory.get(meta.flow)\n"
+            "        if found is None:\n"
+            "            raise RuntimeError(f\"Unknown flow '{meta.flow}' in config metadata\")\n"
+            "        target = found\n"
+            "    elif isinstance(meta.flow, list):\n"
+            "        target = SequentialFlow.make(meta.flow)\n"
+            "    if meta.substituting_steps is not None:\n"
+            "        if meta.flow is None:\n"
+            "            raise RuntimeError('substituting_steps is set but flow is not defined')\n"
+            "        if not issubclass(target, SequentialFlow):\n"
+            "            raise RuntimeError('substituting_steps requires a sequential flow')\n"
+            "        target = target.Substitute(meta.substituting_steps)\n"
+            "steps = []\n"
+            "seen = set()\n"
+            "for step in getattr(target, 'Steps', []) or []:\n"
+            "    step_id = getattr(step, 'id', None)\n"
+            "    if not step_id:\n"
+            "        continue\n"
+            "    if step_id in seen:\n"
+            "        continue\n"
+            "    seen.add(step_id)\n"
+            "    steps.append(step_id)\n"
+            "print(json.dumps({'steps': steps}))\n"
+        )
+        result = subprocess.run(
+            [str(librelane_python), '-c', script, macro_config],
+            cwd=str(working_dir),
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            err = (result.stderr or result.stdout or 'unknown error').strip()
+            return None, err
+        try:
+            payload = json.loads(result.stdout.strip())
+            return payload.get('steps', []), None
+        except Exception as exc:
+            return None, str(exc)
+
+    venv_bin = librelane_venv / 'bin'
+    librelane_python = venv_bin / 'python3'
+    valid_from_steps, valid_from_steps_error = get_valid_from_steps(
+        librelane_python=librelane_python,
+        macro_config=config_file,
+        working_dir=openlane_dir,
+    )
+    if valid_from_steps_error:
+        console.print("[red]✗[/red] Failed to load LibreLane step list for this macro")
+        console.print(f"[yellow]Error:[/yellow] {valid_from_steps_error}")
+        console.print("[yellow]Run 'cf setup --only-openlane' to ensure LibreLane is installed correctly[/yellow]")
+        return
+
+    if list_from_steps:
+        console.print(f"[bold cyan]Valid --from steps for {macro}:[/bold cyan]")
+        if valid_from_steps:
+            for step_name in valid_from_steps:
+                console.print(f"  • {step_name}")
+        else:
+            console.print("[yellow]No steps found for this flow[/yellow]")
+        return
+
+    if from_step and from_step not in valid_from_steps:
+        console.print(f"[red]✗[/red] Invalid --from step: {from_step}")
+        matches = difflib.get_close_matches(from_step, valid_from_steps, n=5, cutoff=0.4)
+        if matches:
+            console.print("[yellow]Did you mean:[/yellow]")
+            for m in matches:
+                console.print(f"  • {m}")
+        else:
+            console.print(f"[yellow]Use 'cf harden {macro} --list-from-steps' to see valid step names[/yellow]")
+        return
     
     # Fetch versions from upstream
     console.print("[dim]Fetching version information from cf-cli repository...[/dim]")
@@ -3849,7 +3992,28 @@ def harden(macro, project_root, list_designs, tag, pdk, use_nix, use_docker, dry
         console.print("[yellow]Run 'cf setup --only-pdk' to install the PDK[/yellow]")
         return
     
-    if not tag:
+    auto_selected_latest_tag = False
+    if (from_step or gui_mode_count) and not tag:
+        runs_dir = macro_dir / 'runs'
+        if not runs_dir.exists():
+            console.print("[red]✗[/red] No existing runs found for this macro")
+            if gui_mode_count:
+                console.print("[yellow]Create a hardening run first, or specify --tag <existing_tag>[/yellow]")
+            else:
+                console.print("[yellow]Run without --from first, or specify --tag <existing_tag>[/yellow]")
+            return
+        candidate_runs = [p for p in runs_dir.iterdir() if p.is_dir()]
+        if not candidate_runs:
+            console.print("[red]✗[/red] No existing runs found for this macro")
+            if gui_mode_count:
+                console.print("[yellow]Create a hardening run first, or specify --tag <existing_tag>[/yellow]")
+            else:
+                console.print("[yellow]Run without --from first, or specify --tag <existing_tag>[/yellow]")
+            return
+        latest_run = max(candidate_runs, key=lambda p: p.stat().st_mtime)
+        tag = latest_run.name
+        auto_selected_latest_tag = True
+    elif not tag:
         tag = datetime.now().strftime('%y_%m_%d_%H_%M')
     
     # Display configuration
@@ -3857,16 +4021,23 @@ def harden(macro, project_root, list_designs, tag, pdk, use_nix, use_docker, dry
     console.print(f"[bold cyan]Hardening: {macro}[/bold cyan]")
     console.print(f"Config: [yellow]{Path(config_file).name}[/yellow]")
     console.print(f"Run tag: [yellow]{tag}[/yellow]")
+    if auto_selected_latest_tag:
+        if gui_mode_count:
+            console.print("[yellow]Using latest existing run tag (auto-selected because GUI mode was requested without --tag)[/yellow]")
+        else:
+            console.print("[yellow]Using latest existing run tag (auto-selected because --from was provided without --tag)[/yellow]")
+    if from_step:
+        console.print(f"Start from: [yellow]{from_step}[/yellow]")
+        console.print("[yellow]Mode:[/yellow] resume from existing state under this tag (no overwrite)")
+    if open_in_openroad:
+        console.print("[yellow]Mode:[/yellow] open existing run in OpenROAD GUI")
+    elif open_in_klayout:
+        console.print("[yellow]Mode:[/yellow] open existing run in KLayout GUI")
     console.print(f"PDK: [yellow]{pdk}[/yellow]")
     console.print(f"PDK Root: [yellow]{pdk_root}[/yellow]")
     console.print(f"Execution: [yellow]{execution_method}[/yellow]")
     console.print("="*60 + "\n")
-    
-    if dry_run:
-        console.print("[bold yellow]Dry run - configuration ready[/bold yellow]")
-        console.print(f"Would use: {execution_method}")
-        return
-    
+
     # Build command based on execution method
     if use_nix:
         # Use Nix to run LibreLane
@@ -3874,22 +4045,30 @@ def harden(macro, project_root, list_designs, tag, pdk, use_nix, use_docker, dry
         
         cmd = [
             'nix', 'run', f'github:chipfoundry/openlane-2/{openlane_version}', '--',
-            '--run-tag', tag,
             '--manual-pdk',
             '--pdk-root', str(pdk_root),
             '--pdk', pdk,
             '--ef-save-views-to', str(project_root_path),
-            '--overwrite',
-            config_file
+            '--run-tag', tag,
         ]
+        if open_in_openroad:
+            cmd.extend(['--flow', 'OpenInOpenROAD'])
+        elif open_in_klayout:
+            cmd.extend(['--flow', 'OpenInKLayout'])
+        elif not from_step:
+            cmd.append('--overwrite')
+        if from_step:
+            cmd.extend(['--from', from_step])
+        cmd.append(config_file)
         
         env = os.environ.copy()
         env.update({
             'PROJECT_ROOT': str(project_root_path),
             'PDK_ROOT': str(pdk_root),
             'PDK': pdk,
-            'LIBRELANE_RUN_TAG': tag,
         })
+        if tag:
+            env['LIBRELANE_RUN_TAG'] = tag
         
     else:
         # Use Docker via venv
@@ -3901,12 +4080,12 @@ def harden(macro, project_root, list_designs, tag, pdk, use_nix, use_docker, dry
             'PROJECT_ROOT': str(project_root_path),
             'PDK_ROOT': str(pdk_root),
             'PDK': pdk,
-            'LIBRELANE_RUN_TAG': tag,
             'PYTHONPATH': str(librelane_venv / 'lib' / f'python{sys.version_info.major}.{sys.version_info.minor}' / 'site-packages')
         })
+        if tag:
+            env['LIBRELANE_RUN_TAG'] = tag
         
         # Add venv to PATH so librelane can find its dependencies
-        venv_bin = librelane_venv / 'bin'
         env['PATH'] = f"{venv_bin}:{env.get('PATH', '')}"
         
         # Build LibreLane command
@@ -3915,7 +4094,6 @@ def harden(macro, project_root, list_designs, tag, pdk, use_nix, use_docker, dry
             str(venv_bin / 'python3'), '-m', 'librelane',
             '-m', str(project_root_path),
             '-m', str(pdk_root),
-            '--dockerized',
         ]
         
         # Add --docker-no-tty if not running in a TTY (e.g., CI environments)
@@ -3925,16 +4103,26 @@ def harden(macro, project_root, list_designs, tag, pdk, use_nix, use_docker, dry
         except:
             # If we can't detect TTY, assume non-TTY (safer for CI)
             cmd.append('--docker-no-tty')
-        
+
+        # --docker-no-tty must come before --dockerized
+        cmd.append('--dockerized')
+
         cmd.extend([
-            '--run-tag', tag,
             '--manual-pdk',
             '--pdk-root', str(pdk_root),
             '--pdk', pdk,
             '--ef-save-views-to', str(project_root_path),
-            '--overwrite',
-            config_file
+            '--run-tag', tag,
         ])
+        if open_in_openroad:
+            cmd.extend(['--flow', 'OpenInOpenROAD'])
+        elif open_in_klayout:
+            cmd.extend(['--flow', 'OpenInKLayout'])
+        elif not from_step:
+            cmd.append('--overwrite')
+        if from_step:
+            cmd.extend(['--from', from_step])
+        cmd.append(config_file)
     
     # Run LibreLane
     
@@ -5206,4 +5394,4 @@ def whoami_cmd():
 
 
 if __name__ == "__main__":
-    main()
+    main()

{chipfoundry_cli-2.4.10 → chipfoundry_cli-2.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "chipfoundry-cli"
-version = "2.4.10"
+version = "2.5.1"
 description = "CLI tool to automate ChipFoundry project submission to SFTP server"
 authors = ["ChipFoundry <marwan.abbas@chipfoundry.io>"]
 readme = "README.md"