feat: add ecc command line tools

.gitignore

@@ -181,4 +181,11 @@ bazel-*
 # Generated from uv.lock, not committed
 requirements_lock.txt
 
-chipcompiler/tools/ecc_dreamplace/dreamplace
+chipcompiler/tools/ecc_dreamplace/dreamplace
+
+.humanize/
+humanize-*
+docs/superpowers/
+findings.md
+progress.md
+task_plan.md

README.cn.md

@@ -24,30 +24,48 @@ ECOS Chip Compiler 是一个**开源芯片设计自动化解决方案**，集成
 GUI（ECOS Studio）已迁移至 [ecos-studio](https://github.com/0xharry/ecos-studio) 仓库。
 
 **使用方式：**
-- **CLI (`cli`)** - 命令行流程执行
+- **CLI (`ecc`)** - 面向项目的命令行流程执行
 - **Python API** - 将 `chipcompiler` 作为库使用
 
 
 ## 快速开始
 
 ### CLI 流程运行
 
-可以使用 `nix run .#cli -- ...` 直接创建 workspace 并执行完整 RTL2GDS 流程。
+可以使用 `nix run .#cli -- ...` 创建 ECC 项目，校验 `ecc.toml`，并执行完整 RTL2GDS 流程。
 
 ```bash
-nix run .#cli -- --workspace ./ws \
-                --rtl ./rtl/top.v \
-                --design top \
-                --top top \
-                --clock clk \
-                --pdk-root /path/to/ics55
-nix run .#cli -- --workspace ./ws \
-                --rtl ./rtl/filelist.f \
-                --design top \
-                --top top \
-                --clock clk \
-                --pdk-root /path/to/ics55 \
-                --freq 200
+nix run .#cli -- init gcd
+cp ./rtl/gcd.v gcd/rtl/gcd.v
+```
+
+编辑 `gcd/ecc.toml`：
+
+```toml
+[design]
+name = "gcd"
+top = "gcd"
+rtl = ["rtl/gcd.v"]
+clock_port = "clk"
+frequency_mhz = 100.0
+
+[pdk]
+name = "ics55"
+root = "/path/to/ics55"
+
+[flow]
+preset = "rtl2gds"
+run = "default"
+```
+
+然后校验并运行：
+
+```bash
+nix run .#cli -- check --project gcd
+nix run .#cli -- run --project gcd
+nix run .#cli -- status --project gcd
+nix run .#cli -- metrics --project gcd
+nix run .#cli -- log --project gcd
 ```
 
 ## 功能特性

README.md

@@ -24,30 +24,49 @@ ECOS Chip Compiler is an **open-source chip design automation solution** that in
 The GUI (ECOS Studio) has been moved to the [ecos-studio](https://github.com/0xharry/ecos-studio) repo.
 
 **How to use:**
-- **CLI (`cli`)** - Command-line flow execution
+- **CLI (`ecc`)** - Project-oriented command-line flow execution
 - **Python API** - Use `chipcompiler` as a library
 
 
 ## Quick Start
 
 ### CLI Flow Runner
 
-Use `nix run .#cli -- ...` to create a workspace and run the full RTL2GDS flow directly.
+Use `nix run .#cli -- ...` to create an ECC project, validate its `ecc.toml`,
+and run the full RTL2GDS flow.
 
 ```bash
-nix run .#cli -- --workspace ./ws \
-                --rtl ./rtl/top.v \
-                --design top \
-                --top top \
-                --clock clk \
-                --pdk-root /path/to/ics55
-nix run .#cli -- --workspace ./ws \
-                --rtl ./rtl/filelist.f \
-                --design top \
-                --top top \
-                --clock clk \
-                --pdk-root /path/to/ics55 \
-                --freq 200
+nix run .#cli -- init gcd
+cp ./rtl/gcd.v gcd/rtl/gcd.v
+```
+
+Edit `gcd/ecc.toml`:
+
+```toml
+[design]
+name = "gcd"
+top = "gcd"
+rtl = ["rtl/gcd.v"]
+clock_port = "clk"
+frequency_mhz = 100.0
+
+[pdk]
+name = "ics55"
+root = "/path/to/ics55"
+
+[flow]
+preset = "rtl2gds"
+run = "default"
+```
+
+Then validate and run:
+
+```bash
+nix run .#cli -- check --project gcd
+nix run .#cli -- run --project gcd
+nix run .#cli -- status --project gcd
+nix run .#cli -- metrics --project gcd
+nix run .#cli -- log --project gcd
 ```
 
 ## Features

chipcompiler/BUILD.bazel

@@ -76,6 +76,12 @@ py_library(
     ],
 )
 
+py_library(
+    name = "chipcompiler_cli_lib",
+    srcs = glob(["cli/**/*.py"]),
+    deps = [":chipcompiler_core"],
+)
+
 py_binary(
     name = "chipcompiler_cli",
     srcs = ["cli/main.py"],
@@ -87,5 +93,7 @@ py_binary(
     env = {
         "CHIPCOMPILER_ICS55_PDK_ROOT": "$(location @icsprout55_pdk//:README.md)/..",
     },
-    deps = [":chipcompiler_core"],
+    deps = [
+        ":chipcompiler_cli_lib",
+    ],
 )

chipcompiler/cli/artifacts.py

@@ -0,0 +1,63 @@
+import os
+
+from chipcompiler.cli.output import disclosure_cmd
+
+KNOWN_ROLES = {"config", "input", "output", "data", "feature", "report", "log", "script", "analysis"}
+
+
+def _role_from_dirname(dirname: str) -> str:
+    return dirname if dirname in KNOWN_ROLES else "unknown"
+
+
+def discover_artifacts(run_dir: str, step_token: str | None = None,
+                       project: str | None = None,
+                       run_id: str | None = None,
+                       project_dir: str | None = None) -> tuple[list[dict], int]:
+    from chipcompiler.cli.inspect import discover_step_dirs, read_flow_json, _safe_steps
+    from chipcompiler.cli.output import normalize_step_name
+
+    base_dir = project_dir or os.path.dirname(os.path.dirname(run_dir))
+    step_dirs = discover_step_dirs(run_dir)
+
+    flow_data = read_flow_json(run_dir)
+    flow_tokens = set()
+    if flow_data is not None and not isinstance(flow_data, str):
+        for s in _safe_steps(flow_data):
+            flow_tokens.add(normalize_step_name(s.get("name", "")))
+
+    if step_token is not None:
+        if step_token not in step_dirs and step_token not in flow_tokens:
+            return [{"kind": "error", "step": step_token,
+                      "status": "unknown_step"}], 1
+        if step_token not in step_dirs:
+            return [], 0
+        tokens = [step_token]
+    else:
+        tokens = sorted(step_dirs.keys())
+
+    artifacts = []
+    for token in tokens:
+        step_path = step_dirs[token]
+        for entry in sorted(os.listdir(step_path)):
+            subdir = os.path.join(step_path, entry)
+            if not os.path.isdir(subdir):
+                continue
+            role = _role_from_dirname(entry)
+            for root, _, files in os.walk(subdir):
+                for fname in sorted(files):
+                    fpath = os.path.join(root, fname)
+                    if os.path.isfile(fpath):
+                        artifacts.append({
+                            "kind": "artifact",
+                            "step": token,
+                            "role": role,
+                            "run": run_id or "default",
+                            "path": os.path.relpath(fpath, base_dir),
+                            "exists": True,
+                            "inspect_cmd": disclosure_cmd(f"ecc artifacts {token} --json", project, run_id),
+                        })
+
+    if not artifacts:
+        return [], 0
+
+    return artifacts, 0

chipcompiler/cli/commands.py

@@ -0,0 +1,38 @@
+from chipcompiler.cli.config import resolve_project_dir
+from chipcompiler.cli.inspect import resolve_run_dir
+from chipcompiler.cli.types import CommandContext, CommandResult, OutputMode
+
+
+def build_context(args) -> CommandContext:
+    project = getattr(args, "project", None)
+    project_dir = resolve_project_dir(project)
+
+    run_id = getattr(args, "run_id", None)
+    run_dir, run_id = resolve_run_dir(project_dir, run_id)
+
+    if getattr(args, "jsonl", False):
+        mode = OutputMode.JSONL
+    elif getattr(args, "json", False):
+        mode = OutputMode.JSON
+    elif getattr(args, "plain", False):
+        mode = OutputMode.PLAIN
+    else:
+        mode = OutputMode.TEXT
+
+    return CommandContext(
+        project_dir=project_dir,
+        project=project,
+        run_dir=run_dir,
+        run_id=run_id,
+        output_mode=mode,
+    )
+
+
+def dispatch(args, ctx: CommandContext) -> CommandResult:
+    from chipcompiler.cli import handlers
+    if args.command == "param":
+        return handlers.param(args, ctx)
+    handler = getattr(handlers, args.command, None)
+    if handler is None:
+        return CommandResult.err([], exit_code=1)
+    return handler(args, ctx)