auriga-cli 1.15.2 → 1.17.0

package/README.md

@@ -11,7 +11,7 @@ This repo itself is a fully configured harness project. You can clone it to see
 | Module | Description |
 |---|---|
 | **Workflow** | `CLAUDE.md` auriga workflow: requirement clarification -> TDD -> Review, Harness principles, Subagent usage guide |
-| **Skills** | Development process + orchestration skills — brainstorming, systematic-debugging, TDD, verification, planning, playwright, test-designer, parallel-implementation |
+| **Skills** | Development process + orchestration skills — brainstorming, systematic-debugging, TDD, verification, planning, playwright, test-designer, incremental-impl |
 | **Recommended Skills** | Optional utility skills (e.g. `codex-agent`, `claude-code-agent`) you can add on top of the workflow skills |
 | **Plugins** | Recommended Claude Code and Codex plugins — skill-creator, claude-md-management, codex, auriga-go, auriga-git-guards, session-instructions-loader, deep-review |
 | **Hooks** | Claude Code hooks: `notify` (macOS notification, focus-aware sound-only when terminal is frontmost — **opt-in**: not installed by `install --all`, requires `install hooks --hook notify`) |
@@ -50,6 +50,18 @@ npx -y auriga-cli --help                     # full catalog + flags
 
 Exit codes: `0` success, `1` fatal (precheck / parse / fetch), `2` partial success — `stderr` lists per-category `[OK]/[FAIL]` and a `Retry:` hint. After install, reload the Claude Code or Codex session so the new `CLAUDE.md` / skills / plugins / hook registrations are picked up.
 
+### Web UI (opt-in)
+
+For a browser-based view of what's installed and one-click apply, run:
+
+```bash
+npx auriga-cli web-ui
+```
+
+This boots a local server on `127.0.0.1`, opens your default browser, and serves a dashboard that scans the current project, shows each module's status (installed / update-available / not-installed), and applies install / update / uninstall in a queue with live SSE progress. The server shuts down on its own ~15 s after the browser closes.
+
+The UI is opt-in — `npx auriga-cli` still launches the TTY menu below.
+
 ### Interactive menu
 
 ```bash
@@ -91,7 +103,7 @@ Installs selected skills via `npx skills add`, targeting both Claude Code and Co
 | planning-with-files | [OthmanAdi/planning-with-files](https://github.com/OthmanAdi/planning-with-files) | File-based task planning and progress tracking |
 | playwright-cli | [microsoft/playwright-cli](https://github.com/microsoft/playwright-cli) | Browser automation and testing |
 | test-designer | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | Independent-Evaluation test designer for TDD red phase |
-| parallel-implementation | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | Slice planner for parallel multi-subagent code writing |
+| incremental-impl | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | Decides how to implement a non-trivial change: size, slicing strategy, optional parallel dispatch, per-slice execution discipline |
 | session-compound | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | Post-merge session compounder — distills the session into an interactive HTML report (timeline + token / cache / tool health + playground for skill installs / AGENTS.md edits / new-skill gaps) |
 
 **Recommended Skills (opt-in, not installed by `--all`):**

package/README.zh-CN.md

@@ -11,7 +11,7 @@
 | 模块 | 说明 |
 |---|---|
 | **Workflow** | `CLAUDE.md` 里的 auriga 工作流：需求澄清 → TDD → Review，Harness 原则，Subagent 使用指南 |
-| **Skills** | 开发流程 + 编排类 skills —— brainstorming、systematic-debugging、TDD、verification、planning、playwright、test-designer、parallel-implementation |
+| **Skills** | 开发流程 + 编排类 skills —— brainstorming、systematic-debugging、TDD、verification、planning、playwright、test-designer、incremental-impl |
 | **Recommended Skills** | 可选的工具类 skills（如 `codex-agent`、`claude-code-agent`），在 workflow skills 之外按需追加 |
 | **Plugins** | 推荐的 Claude Code 和 Codex 插件 —— skill-creator、claude-md-management、codex、auriga-go、auriga-git-guards、session-instructions-loader、deep-review |
 | **Hooks** | Claude Code hooks：`notify`（macOS 通知，终端在焦点时仅放声不弹横幅 —— **opt-in**：`install --all` 不装，需要 `install hooks --hook notify`） |
@@ -50,6 +50,18 @@ npx -y auriga-cli --help                     # 完整 catalog + flag 说明
 
 退出码：`0` 成功；`1` 致命错误（前置检查 / 解析 / 拉取失败）；`2` 部分成功——`stderr` 会列出逐类 `[OK]/[FAIL]` 和 `Retry:` 提示。装完后请重启 Claude Code 或 Codex 会话，让新的 `CLAUDE.md` / skills / plugins / hook 注册生效。
 
+### Web UI（可选）
+
+如果想在浏览器里看到“已装 / 可更新 / 未装”全景并一键 apply，跑：
+
+```bash
+npx auriga-cli web-ui
+```
+
+它会在 `127.0.0.1` 起一个本地 server、自动开浏览器，扫描当前项目并展示 5 个分类的状态。勾选要安装/更新/卸载的项目后点 Apply，SSE 实时回传执行进度。关浏览器后约 15 秒 server 自动退出。
+
+Web UI 是显式入口；`npx auriga-cli` 仍然走下面的 TTY 菜单。
+
 ### 交互式菜单
 
 ```bash
@@ -91,7 +103,7 @@ npx auriga-cli
 | planning-with-files | [OthmanAdi/planning-with-files](https://github.com/OthmanAdi/planning-with-files) | 文件化任务计划与进度跟踪 |
 | playwright-cli | [microsoft/playwright-cli](https://github.com/microsoft/playwright-cli) | 浏览器自动化与测试 |
 | test-designer | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | TDD 红灯阶段的 Independent Evaluation 测试设计器 |
-| parallel-implementation | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | 多 subagent 并行写代码时的切片计划器 |
+| incremental-impl | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | 决定如何实现非平凡改动：估算大小、选择切片策略、按需并行派遣、执行片间纪律 |
 | session-compound | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | PR 合并后的会话复利 skill — 将本次会话沉淀为交互式 HTML 报告（时间线 + token / cache / 工具健康度 + playground：skill 安装 / AGENTS.md 修改 / 新建 skill 缺口） |
 
 **Recommended Skills（可选，不在 `--all` 内）：**

package/dist/api-types.d.ts

@@ -0,0 +1,115 @@
+export type ItemStatus = "installed" | "update-available" | "not-installed";
+export interface StateReport {
+    /** Absolute path to the project the server was launched against. Surfaced
+     *  in the UI's top bar so users know where Apply will write project-scope
+     *  changes. The path may be redacted (e.g. `~/...` home expansion) but the
+     *  contract is "human-readable identifier for the current cwd". */
+    cwd: string;
+    workflow: WorkflowState;
+    skills: SkillState[];
+    recommendedSkills: SkillState[];
+    plugins: PluginState[];
+    hooks: HookState[];
+    warnings: StateWarning[];
+}
+export interface WorkflowState {
+    status: ItemStatus;
+    currentVersion?: string;
+    expectedVersion: string;
+}
+export interface SkillState {
+    name: string;
+    description: string;
+    status: ItemStatus;
+    isWorkflow: boolean;
+    currentHash?: string;
+    expectedHash: string;
+}
+export type ApplyAgent = "claude" | "codex";
+export interface PluginState {
+    id: string;
+    description: string;
+    status: ItemStatus;
+    /** Which Agent runtimes this plugin can install into. Most plugins target
+     *  a single agent; dual-Agent plugins (e.g. auriga-go) have both. When
+     *  `agents.length === 2` the UI shows a BOTH badge and Apply installs to
+     *  each agent in turn. Status is aggregated across all targeted agents:
+     *  `installed` ⇔ all agents installed; `not-installed` ⇔ all not-installed;
+     *  any partial state (one side installed, other not) → `update-available`
+     *  so a single Apply backfills the missing side. */
+    agents: ApplyAgent[];
+    currentVersion?: string;
+    expectedVersion?: string;
+    versionSource: "upstream-live" | "catalog";
+}
+export interface HookState {
+    name: string;
+    description: string;
+    status: ItemStatus;
+    currentHash?: string;
+    expectedHash: string;
+}
+export interface StateWarning {
+    code: "claude-cli-missing" | "codex-cli-missing" | "marketplace-offline";
+    message: string;
+}
+export type ApplyCategory = "workflow" | "skill" | "recommended-skill" | "plugin" | "hook";
+export type ApplyAction = "install" | "update" | "uninstall";
+/**
+ * Installer scope. Carried per-item so the Web UI can mix scopes within a
+ * single apply batch.
+ *
+ * - workflow: no scope; field MUST be omitted.
+ * - skill / recommended-skill / plugin: "project" | "user". Default project.
+ * - hook: "project" | "user" for v0.1 (project-local deferred to v0.2).
+ */
+export type ApplyScope = "project" | "user";
+/**
+ * Workflow CLAUDE.md language variant.
+ *
+ * - "en":    English CLAUDE.md (the default).
+ * - "zh-CN": Simplified Chinese CLAUDE.md (the localized variant).
+ *
+ * Only meaningful for `category === "workflow"`; rejected for other
+ * categories so the API surface stays explicit.
+ */
+export type ApplyLang = "en" | "zh-CN";
+export interface ApplyItemRef {
+    category: ApplyCategory;
+    name: string;
+    action: ApplyAction;
+    /** Installer scope. Omitted = "project" (back-compat default). The server
+     *  rejects this field for category="workflow" because workflow has no
+     *  scope concept (it's a single file at the project root). */
+    scope?: ApplyScope;
+    /** Workflow CLAUDE.md language variant. Omitted = "en" (back-compat
+     *  default). The server rejects this field for any non-workflow
+     *  category. */
+    lang?: ApplyLang;
+}
+export interface ApplyRequest {
+    items: ApplyItemRef[];
+}
+export interface ApplyResponse {
+    jobId: string;
+}
+export type ProgressEvent = {
+    type: "item:start";
+    index: number;
+    total: number;
+    item: ApplyItemRef;
+} | {
+    type: "item:log";
+    index: number;
+    line: string;
+    level: "info" | "warn" | "error";
+} | {
+    type: "item:done";
+    index: number;
+    success: boolean;
+    error?: string;
+} | {
+    type: "all-done";
+    success: boolean;
+    failedCount: number;
+};

package/dist/api-types.js

@@ -0,0 +1,4 @@
+// Shared API types between server (src/server.ts) and the Web UI frontend
+// (ui/). All /api/* endpoints carry token + Origin auth. See spec
+// docs/architecture/web-ui.md §6.2 for the contract these types encode.
+export {};

package/dist/apply-handlers.d.ts

@@ -0,0 +1,17 @@
+import type { ApplyLang } from "./api-types.js";
+import type { ApplyHandlers } from "./server.js";
+export interface ApplyHandlerContext {
+    /** Where auriga-cli lives — source of skills-lock.json + .claude config. */
+    packageRoot: string;
+    /** Target project directory. Installers write here. */
+    cwd: string;
+    /** Resolves plugin name → the list of agents this plugin can install
+     *  into. Built at boot from the same scan catalog the /api/state route
+     *  uses. dual-Agent plugins (e.g. `auriga-go`) yield `["claude","codex"]`
+     *  and the handler iterates the list, installing to each agent in turn.
+     *  Names not in the map default to `["claude"]` (existing CLI default). */
+    pluginAgentsByName: Map<string, ("claude" | "codex")[]>;
+    /** Workflow language for install. Defaults to "en". */
+    workflowLang?: ApplyLang;
+}
+export declare function buildDefaultApplyHandlers(ctx: ApplyHandlerContext): ApplyHandlers;

package/dist/apply-handlers.js

@@ -0,0 +1,186 @@
+// Builds the default ApplyHandlers map that wires the Web UI's /api/apply
+// route to the real installers in workflow.ts / skills.ts / plugins.ts /
+// hooks.ts. Tests inject their own mock handlers; CLI mode (the `web-ui`
+// subcommand) calls `buildDefaultApplyHandlers` at boot.
+//
+// Per-item dispatch is layered on top of the existing bulk installers via
+// `opts.selected = [name]`. The recipe per category:
+//
+//   workflow:           installWorkflow(packageRoot, …) ─┐
+//   workflow:           uninstallWorkflow({force:true,…})│  no name needed
+//   skill:              installSkills(…, selected:[name])│
+//   skill:              uninstallSkill(name, …)          │
+//   recommended-skill:  installRecommendedSkills(…)      │
+//   recommended-skill:  uninstallSkill(name, …)          │  same store
+//   plugin:             installPlugins(…, agent, sel:[]) │  per-name
+//   plugin:             uninstallPlugin(name, agent, …)  │
+//   hook:               installHook(hookDef, "project",…)│  needs HookDef
+//   hook:               uninstallHook(name, …)           │
+//
+// Spec: docs/architecture/web-ui.md §6.4 (apply execution model).
+import { installHook, loadHooksConfig, uninstallHook } from "./hooks.js";
+import { installPlugins, uninstallPlugin, } from "./plugins.js";
+import { installRecommendedSkills, installSkills, uninstallSkill, } from "./skills.js";
+import { installWorkflow, uninstallWorkflow } from "./workflow.js";
+const ALL_ACTIONS = new Set([
+    "install",
+    "update",
+    "uninstall",
+]);
+function assertAction(action) {
+    // Defense in depth — the server validates the shape already, but the
+    // adapter must not silently fall through if a new action is added later.
+    if (!ALL_ACTIONS.has(action)) {
+        throw new Error(`unsupported action: ${action}`);
+    }
+}
+export function buildDefaultApplyHandlers(ctx) {
+    const { packageRoot, cwd, pluginAgentsByName } = ctx;
+    const lang = ctx.workflowLang ?? "en";
+    const workflow = async (action, _name, { onLog, lang: requestedLang }) => {
+        assertAction(action);
+        // Per-item lang overrides the ctx default (the UI now drives this via
+        // the Workflow column's EN/ZH-CN picker). Falls back to ctx lang for
+        // CLI-mode callers that don't pass it.
+        const installLang = requestedLang ?? lang;
+        if (action === "install" || action === "update") {
+            await installWorkflow(packageRoot, {
+                interactive: false,
+                cwd,
+                lang: installLang,
+            });
+            onLog(`workflow installed (${installLang})`, "info");
+            return;
+        }
+        // uninstall
+        await uninstallWorkflow({
+            force: true,
+            cwd,
+            onLog: (line) => onLog(line, "info"),
+        });
+    };
+    // Adapter from InstallOpts.onLog (stdout|stderr) → handler's onLog
+    // (info|warn|error). stderr lines surface as warnings; the SSE consumer
+    // can decide whether to render them differently.
+    const streamLog = (onLog) => (line, stream) => {
+        onLog(line, stream === "stderr" ? "warn" : "info");
+    };
+    const skill = async (action, name, { onLog, scope }) => {
+        assertAction(action);
+        const installScope = scope ?? "project";
+        if (action === "install" || action === "update") {
+            await installSkills(packageRoot, {
+                interactive: false,
+                cwd,
+                selected: [name],
+                scope: installScope,
+                onLog: streamLog(onLog),
+            });
+            onLog(`skill ${name} installed (${installScope})`, "info");
+            return;
+        }
+        await uninstallSkill(name, {
+            cwd,
+            scope: installScope,
+            onLog: (line) => onLog(line, "info"),
+        });
+    };
+    const recommendedSkill = async (action, name, { onLog, scope }) => {
+        assertAction(action);
+        const installScope = scope ?? "project";
+        if (action === "install" || action === "update") {
+            await installRecommendedSkills(packageRoot, {
+                interactive: false,
+                cwd,
+                selected: [name],
+                scope: installScope,
+                onLog: streamLog(onLog),
+            });
+            onLog(`recommended skill ${name} installed (${installScope})`, "info");
+            return;
+        }
+        // Uninstall path is the same regardless of workflow vs recommended —
+        // both live in skills-lock.json + .claude/skills/<name>.
+        await uninstallSkill(name, {
+            cwd,
+            scope: installScope,
+            onLog: (line) => onLog(line, "info"),
+        });
+    };
+    const plugin = async (action, name, { onLog, scope }) => {
+        assertAction(action);
+        const agents = pluginAgentsByName.get(name) ?? ["claude"];
+        const installScope = scope ?? "project";
+        // dual-Agent plugins (length === 2) install into each agent in turn.
+        // Per-agent try/catch: if Claude install fails, still try Codex so
+        // partial coverage is visible to the user. Failures are aggregated
+        // and thrown at the end → SSE marks the item failed but onLog
+        // shows both agent outcomes.
+        const failures = [];
+        for (const agent of agents) {
+            try {
+                if (action === "install" || action === "update") {
+                    await installPlugins(packageRoot, {
+                        interactive: false,
+                        cwd,
+                        agent,
+                        selected: [name],
+                        scope: installScope,
+                        onLog: streamLog(onLog),
+                    });
+                    onLog(`plugin ${name} installed (${agent}, ${installScope})`, "info");
+                }
+                else {
+                    await uninstallPlugin(name, agent, {
+                        cwd,
+                        onLog: (line) => onLog(`[${agent}] ${line}`, "info"),
+                    });
+                    onLog(`plugin ${name} uninstalled (${agent})`, "info");
+                }
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                failures.push({ agent, error });
+                onLog(`plugin ${name} ${action} failed (${agent}): ${error.message}`, "error");
+            }
+        }
+        if (failures.length > 0) {
+            const summary = failures
+                .map((f) => `${f.agent}: ${f.error.message}`)
+                .join("; ");
+            throw new Error(`plugin ${name} ${action} failed for ${failures.length} agent(s) — ${summary}`);
+        }
+    };
+    const hook = async (action, name, { onLog, scope }) => {
+        assertAction(action);
+        const installScope = scope ?? "project";
+        if (action === "uninstall") {
+            await uninstallHook(name, {
+                cwd,
+                scope: installScope,
+                onLog: (line) => onLog(line, "info"),
+            });
+            return;
+        }
+        // install + update both run installHook with the requested scope. The
+        // hook installer is idempotent — re-running == "update". Look up the
+        // HookDef in the bundled registry; unknown name → loud throw so the
+        // SSE caller surfaces it as item:done success=false.
+        const config = loadHooksConfig(packageRoot);
+        const hookDef = config.hooks.find((h) => h.name === name);
+        if (!hookDef) {
+            throw new Error(`hook not found in registry: ${name}`);
+        }
+        // installHook takes a wider Scope union ("project"|"user"|"project-local");
+        // v0.1 only exposes "project"|"user" via the API. Cast is safe.
+        await installHook(hookDef, scope ?? "project", cwd, packageRoot);
+        onLog(`hook ${name} installed (${scope ?? "project"})`, "info");
+    };
+    return {
+        workflow,
+        skill,
+        "recommended-skill": recommendedSkill,
+        plugin,
+        hook,
+    };
+}

package/dist/catalog.json

@@ -1,13 +1,13 @@
 {
-  "generatedAt": "2026-05-12T10:06:21.744Z",
+  "generatedAt": "2026-05-12T11:30:47.843Z",
   "workflowSkills": [
     {
       "name": "brainstorming",
       "description": "You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation."
     },
     {
-      "name": "parallel-implementation",
-      "description": "Plan how to slice a non-trivial coding task across parallel subagents. Returns a dispatch plan (file assignments, dependencies, output-format contracts) — the main Agent then executes it with the Agent tool + `isolation: \"worktree\"`. Invoke only when work justifies multi-agent overhead: (a) greenfield 0→1 across multiple independent modules, (b) change touches ≥3 modules, or (c) ≥5 files each with >50 lines of diff. Small changes write inline."
+      "name": "incremental-impl",
+      "description": "Plan a non-trivial code change end-to-end — size triage (XS–XL), slicing strategy, optional parallel subagent dispatch, per-slice Implement → Test → Verify → Commit discipline. Use for any multi-file change, refactor across files, executing a planned task from any planning source, cross-cutting modification (analytics sweep / i18n / library migration), or when about to write more than ~100 lines. 也用于增量实现 / 切片落地 / 推进已规划任务 / 跨切面改动。Skip only for trivial XS edits and pure documentation / configuration changes."
     },
     {
       "name": "planning-with-files",

package/dist/cli.d.ts

@@ -11,6 +11,16 @@ export interface InstallParsed {
     scope?: "project" | "user";
     agent?: PluginAgent;
 }
+export interface UiParsed {
+    /** Override the default port (4747). When set, the fallback range is
+     *  also skipped — we either succeed on this port or fail. */
+    port?: number;
+    /** Override ui-fetch; serve from this local directory instead. Useful
+     *  for development against `ui/dist` without a release tag. */
+    uiDir?: string;
+    /** Skip opening the browser. Prints the URL only. */
+    noOpen?: boolean;
+}
 export type ParsedArgs = {
     command: "help";
     helpType?: CategoryName;
@@ -21,6 +31,9 @@ export type ParsedArgs = {
 } | {
     command: "install";
     install: InstallParsed;
+} | {
+    command: "web-ui";
+    ui: UiParsed;
 };
 export declare function parseArgs(argv: string[]): ParsedArgs;
 export declare function main(argv: string[]): Promise<number>;