abelworkflow 1.1.2 → 1.2.0

package/lib/templates/workflow/commands/abel-implement.md

@@ -1,170 +1,50 @@
 ---
 name: abel-implement
-description: Implement approved changes with mandatory TDD.
+description: Implement an OpenSpec change with test-first Red, Green, Refactor cycles.
 category: abel
 tags: [abel, implementation, TDD]
 argument-hint: [change_name]
 ---
 
 <!-- ABEL:START -->
-**Arguments**
-- Requested: `<change_name>`
+# abel-implement
 
-**Guardrails**
+Implement one ready OpenSpec change with minimal, verified patches.
 
-- Keep changes tightly scoped to the requested outcome; enforce side-effect review before applying any modification.
-- Minimize documentation—avoid unnecessary comments; prefer self-explanatory code.
-- Refer to `openspec/AGENTS.md` (located inside the `openspec/` directory—run `ls openspec` or `openspec update` if you don't see it) for additional OpenSpec conventions or clarifications.
+## Rules
 
-**TDD Guardrails (mandatory)**
-- **Red Phase**: Create or execute the task's failing executable verification ONLY; implementation code is FORBIDDEN.
-- **Green Phase**: Write MINIMAL code to satisfy the verification; over-engineering is FORBIDDEN.
-- **Refactor Phase**: Optimize code quality while keeping target and affected verification green and introducing no new full-suite failures.
-- **Mandatory**: Run the task's executable verification after EVERY code change; never skip verification.
-- **Test-First**: Each task MUST have a failing executable verification before implementation begins.
+- Follow the repository instructions and the Implement column of its Stage Skill Matrix.
+- Before any write, state assumptions and unknowns explicitly. If a critical unknown could change behavior, scope, architecture, or safety, stop and ask the user or return to `/abel-design --change <change-name>`.
+- Retrieve project context with `rg`, `rg --files`, `git grep`, and direct file reads.
+- Use unified diff patches and stay inside the task's declared scope. Do not invent missing product or architecture decisions.
 
-**Skill Integration**: See `Stage Skill Matrix` (Implement column)
+## Readiness
 
-**Readiness Preflight (before any code or test write)**
+1. Resolve `<change-name>` from the explicit argument; ask only if it is missing or ambiguous.
+2. Run `openspec status --change <change-name> --json`. Read `schemaName`, `changeRoot`, `artifactPaths`, `applyRequires`, and artifact states; every required artifact must be done.
+3. Inspect `openspec schema which <schemaName> --json`. Resolve its concrete `apply.tracks` file inside `changeRoot`; never guess a task filename.
+4. Run `openspec validate <change-name> --strict --type change` and `openspec instructions apply --change <change-name> --json`.
+5. Read the reported artifacts, tracking file, affected source, and nearby tests. Confirm that every task states scope, dependencies, Requirement/Scenario, Red failure, Green behavior, and verification commands.
+6. Run the affected tests and full suite as a baseline. Record commands, exit status, and existing failure identities; an existing failure is not the target Red.
 
-1. Explicit argument takes precedence. Resolve it directly; ask only when the argument is missing or cannot be resolved uniquely. Never require unconditional `openspec view` confirmation.
-2. Run `openspec status --change <change-name> --json`; read `schemaName`, `changeRoot`, `artifactPaths`, `applyRequires`, and `artifacts`.
-3. Run `openspec schema which <schemaName> --json`, read the resolved `schema.yaml`, and extract `apply.tracks`. Resolve `apply.tracks` relative to `changeRoot`; it must name one concrete existing regular file inside `changeRoot`. Missing, null, non-concrete, or escaping paths fail closed; do not infer the tracking path from apply-instruction `contextFiles` or `tasks`.
-4. Every artifact id in `applyRequires` must have status `done`; array presence or a general completion flag is insufficient.
-5. Run `openspec validate <change-name> --strict --type change`; require zero issues.
-6. Read every planning artifact reported by `artifactPaths`, then run `openspec instructions apply --change <change-name> --json` and follow the returned apply contract.
-7. Verify stable Requirement and Scenario references, the Requirement → Scenario → Verification → Task chain, and every task verification contract. Rebuild the Gate A and Gate B summaries; if approval cannot be proven in the current conversation, show the summaries and require explicit user confirmation.
-8. Run and record affected baseline tests and the full test suite before any write. Record each command, exit status, and normalized failure identities/reasons. Keep existing failures from the full suite separate from the target Red; an existing failure never counts as Red.
-9. If any preflight item fails, STOP and return `/abel-design --change <change-name>`. Do not invent or repair product, behavior, or architecture decisions here.
+If readiness is incomplete or inconsistent, stop without product writes and return the issue to design.
 
-**Tool Routing**:
-- **TDD Cycle**: Autonomous refactoring
-- **Final Review** (after all tasks):
-  - Backend refactor (subagents)
-  - Frontend refactor (subagents)
-- **E2E tasks** → `/dev-browser`
+## TDD Cycle
 
-After preflight, detect the project's verification tooling and work through the tracked tasks sequentially.
+For each incomplete task, in dependency order:
 
-**TDD Cycle (per task)**
+1. Red: add or update the smallest executable test or static check, then run it. It must fail for the target's expected reason before implementation changes. If it passes or fails for another reason, stop and resolve the mismatch.
+2. Green: apply the minimal implementation patch and rerun the Red command until it passes.
+3. Refactor: simplify only where useful, keeping the target and affected tests green after each code change.
+4. Run the task's affected verification. Review the diff for unintended behavior, unrelated edits, security issues, and leaked runtime state.
+5. Leave the task incomplete in `apply.tracks` until final verification succeeds.
 
-Consume these ordinary indented bullets from the task verification contract, never Markdown checkboxes:
-- verification type: property | example | E2E | static
-- Red command and expected failure reason
-- Green expected behavior
-- affected-suite command
-- target scope/files
+## Final Verification
 
-- Red must fail because of the target defect described by the contract.
-- If the failure reason differs or the command is invalid, STOP and return `/abel-design --change <change-name>`; do not improvise a replacement contract.
-- A non-behavior-change task starts with its specified failing executable static verification.
-- A manual-only task is not implementation-ready; STOP and return `/abel-design --change <change-name>`.
-
-```
-┌─────────────────────────────────────────────────────────┐
-│ Step 1: 🔴 Red Phase - Execute Contract Verification    │
-│   ├─ Use the contract's verification type and scope     │
-│   ├─ Generate the required failing verification via     │
-│   │   PROMPT: "Generate failing verification for: {task}│
-│   │            Context: {code_context}                  │
-│   │            Output: unified diff patch               │
-│   │            FORBIDDEN: implementation code"          │
-│   ├─ Apply verification code (after review)             │
-│   ├─ Run Red command → MUST FAIL for expected reason    │
-│   └─ If it passes or fails differently → STOP           │
-├─────────────────────────────────────────────────────────┤
-│ Step 2: 🟢 Green Phase - Minimal Implementation         │
-│   ├─ Generate minimal implementation                    │
-│   │   PROMPT: "Generate minimal code for verification:  │
-│   │            Verification: {verification_context}     │
-│   │            Context: {code_context}                  │
-│   │            Output: unified diff patch               │
-│   │            FORBIDDEN: over-engineering"             │
-│   ├─ Apply implementation (after review & rewrite)      │
-│   ├─ Run Red command → MUST PASS                        │
-│   └─ If fails → analyze error, fix, retry               │
-├─────────────────────────────────────────────────────────┤
-│ Step 3: 🔵 Refactor Phase                               │
-│   ├─ Analyzes code quality                              │
-│   ├─ Apply standard refactoring techniques:             │
-│   │   ├─ Eliminate code duplication                     │
-│   │   ├─ Improve naming and structure                   │
-│   │   ├─ Enhance readability                            │
-│   │   └─ Simplify logic where possible                  │
-│   ├─ Apply refactoring changes                          │
-│   ├─ Run affected-suite command → MUST STILL PASS       │
-│   └─ If fails → rollback refactoring                    │
-└─────────────────────────────────────────────────────────┘
-```
-
-Before applying any change, perform mandatory side-effect review.
-
-After a task's TDD cycle completes, locate the task ID's checkbox in the concrete tracking file resolved from schema `apply.tracks`; require exactly one match and update only it. Zero or multiple matches must STOP and return `/abel-design --change <change-name>`. Never hardcode an artifact filename or infer the tracking path from apply instructions.
-
-**Final Review & Refactor** (after all tasks complete)
-
-1. Require all target tests to be green, then run the affected suites.
-2. Re-run the same full-suite command (the full test suite), compare normalized failure identities with the recorded full-suite baseline, and require no new failures.
-
-3. Execute global code review via subagents:
-
-4. Wait for background tasks to complete; review diff patches.
-5. Rewrite patches into production-grade code (per rewriting principle).
-6. Apply refactoring changes.
-7. Re-run target, affected, and full-suite verification against the baseline.
-8. If a target test fails or the full suite has a new failure, analyze the root cause and fix or roll back.
-9. Perform final side-effect review.
-10. Report that the change is ready for archive; do not archive until the user explicitly authorizes `/opsx:archive`.
-
-**TDD Output Format**
-
-```
-## /abel-implement (TDD Mode)
-
-### Task 1/N: {task_description}
-
-🔴 Red Phase
-├─ Type: {verification_type}
-├─ Generated: {verification_files_or_none}
-├─ Run: {red_command}
-└─ Result: failed for {expected_failure_reason} ✓
-
-🟢 Green Phase
-├─ Generated: {implementation_files}
-├─ Run: {red_command}
-└─ Result: {green_expected_behavior} ✓
-
-🔵 Refactor Phase (Agent autonomous)
-├─ Optimized: {description}
-├─ Run: {affected_suite_command}
-└─ Result: target verification green ✓
-
-✓ Task complete → Next task
-
----
-
-### All Tasks Complete
-
-🔍 Final Review & Refactor
-
-Backend Review
-├─ Files: {backend_files}
-├─ Status: Running in background...
-└─ Task ID: {task_id}
-
-Frontend Review
-├─ Files: {frontend_files}
-├─ Status: Running in background...
-└─ Task ID: {task_id}
-
-[Waiting for completion...]
-
-✓ Reviews complete
-├─ Applied: {refactoring_summary}
-├─ Target tests: green ✓
-├─ Full suite: no failures beyond baseline ✓
-└─ Ready for user-authorized archive
-
-✓ Implementation complete
-```
+- Run all target tests, affected suites, and the same full-suite baseline command. Require no new failure identities.
+- Rerun `openspec validate <change-name> --strict --type change` and inspect `openspec status --change <change-name> --json`.
+- Only after those checks pass, mark each implemented task complete in the file resolved from `apply.tracks`; require exactly one matching task ID. Rerun validation and status after this completion-only patch.
+- If any verification fails, ensure those tasks remain incomplete or restore them to incomplete so a resumed run selects them again.
+- Review the complete unified diff and report changed files, Red/Green evidence, final verification, baseline exceptions, and residual risks.
+- Do not archive automatically; `/opsx:archive` remains a separate user-authorized action.
 <!-- ABEL:END -->

package/lib/templates/workflow/commands/abel-init.md

@@ -14,7 +14,7 @@ tags: [openspec, init, setup]
 **Steps**
 1. Detect OS and adapt command style (Unix/PowerShell).
 2. Verify `openspec` availability via `openspec --version`.
-3. If missing, `npm install -g @fission-ai/openspec@latest`, then re-check version.
+3. If missing, stop and report `npm install -g @fission-ai/openspec` as manual remediation; do not run it automatically.
 4. Run `openspec init` (or `openspec update` for existing projects).
 5. Verify required skills:
    - Skills: `/dev-browser` `/context7-auto-research` `/grok-search`

package/lib/tools/cli-installer.mjs

@@ -1,47 +1,20 @@
 import { spawn, spawnSync } from "node:child_process";
-import { join } from "node:path";
 import * as p from "@clack/prompts";
 import c from "picocolors";
-import { defaultPaths, getPlatform, isWindows } from "../paths.mjs";
-
-const { homeDir: home } = defaultPaths;
+import { getPlatform, isWindows } from "../paths.mjs";
 
 function getRunCommandSpawnOptions(platform = getPlatform()) {
   return { stdio: "inherit", shell: platform === "win32" };
 }
 
-function getCommandPath(command) {
-  const checker = isWindows() ? "where" : "which";
-  const result = spawnSync(checker, [command], { encoding: "utf8" });
-  if (result.status !== 0) {
-    return undefined;
-  }
-  return result.stdout
-    .split(/\r?\n/u)
-    .map((line) => line.trim())
-    .find(Boolean);
-}
-
 function commandExists(command) {
-  return Boolean(getCommandPath(command));
-}
-
-function readCommandOutput(command, args) {
-  const result = spawnSync(command, args, {
-    encoding: "utf8",
-    shell: isWindows(),
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  if (result.status !== 0) {
-    return undefined;
-  }
-  const outputValue = result.stdout.trim();
-  return outputValue || undefined;
+  const checker = isWindows() ? "where" : "which";
+  return spawnSync(checker, [command], { stdio: "ignore" }).status === 0;
 }
 
 async function runCommand(command, args) {
   await new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn(command, args, getRunCommandSpawnOptions(getPlatform()));
+    const child = spawn(command, args, getRunCommandSpawnOptions());
     child.on("error", rejectPromise);
     child.on("close", (code) => {
       if (code === 0) {
@@ -53,109 +26,20 @@ async function runCommand(command, args) {
   });
 }
 
-function normalizeInstallPath(value) {
-  if (!value) {
-    return "";
-  }
-  return value.replace(/\\/gu, "/").replace(/\/+$/u, "").toLowerCase();
-}
-
-function installPathIsWithin(path, parentPath) {
-  const normalizedPath = normalizeInstallPath(path);
-  const normalizedParent = normalizeInstallPath(parentPath);
-  return Boolean(normalizedPath && normalizedParent)
-    && (normalizedPath === normalizedParent || normalizedPath.startsWith(`${normalizedParent}/`));
-}
-
-function getNpmGlobalBinDirs(npmGlobalPrefix, platform = getPlatform()) {
-  if (!npmGlobalPrefix) {
-    return [];
-  }
-  return platform === "win32" ? [npmGlobalPrefix] : [join(npmGlobalPrefix, "bin")];
-}
-
-function inferPackageManagerFromCommandPath(commandPath, {
-  bunGlobalBinDir,
-  npmGlobalPrefix,
-  platform = getPlatform()
-} = {}) {
-  if (installPathIsWithin(commandPath, bunGlobalBinDir)) {
-    return "bun";
-  }
-  if (getNpmGlobalBinDirs(npmGlobalPrefix, platform)
-    .some((binDir) => installPathIsWithin(commandPath, binDir))) {
-    return "npm";
-  }
-  return null;
-}
-
-function chooseCliInstallPackageManager({
-  commandPath,
-  availablePackageManagers = [],
-  bunGlobalBinDir,
-  npmGlobalPrefix,
-  platform = getPlatform(),
-  nodeAvailable = true,
-  supportedPackageManagers = ["bun", "npm"]
-} = {}) {
-  const supported = new Set(supportedPackageManagers);
-  const available = new Set(availablePackageManagers.filter((packageManager) => {
-    if (!supported.has(packageManager)) {
-      return false;
-    }
-    return packageManager !== "bun" || nodeAvailable;
-  }));
-  const bunBlockedByMissingNode = !nodeAvailable
-    && supported.has("bun")
-    && availablePackageManagers.includes("bun");
-  const existingPackageManager = inferPackageManagerFromCommandPath(commandPath, {
-    bunGlobalBinDir,
-    npmGlobalPrefix,
-    platform
-  });
-
-  if (existingPackageManager && available.has(existingPackageManager)) {
-    return { packageManager: existingPackageManager, source: "existing" };
-  }
-  for (const packageManager of ["bun", "npm"]) {
-    if (available.has(packageManager)) {
-      return { packageManager, source: "available" };
-    }
-  }
+function buildCliToolInstallCommand({ packageName, skipScripts = false }) {
   return {
-    packageManager: null,
-    source: bunBlockedByMissingNode ? "missing-node" : (availablePackageManagers.length > 0 ? "unsupported" : "missing")
+    command: "npm",
+    args: [
+      "install",
+      "-g",
+      ...(skipScripts ? ["--ignore-scripts"] : []),
+      packageName,
+      "--force"
+    ]
   };
 }
 
-function buildCliToolInstallCommand(packageManager, { packageName, skipScripts = false }) {
-  if (packageManager === "npm") {
-    return {
-      command: "npm",
-      args: [
-        "install",
-        "-g",
-        ...(skipScripts ? ["--ignore-scripts"] : []),
-        packageName,
-        "--force"
-      ]
-    };
-  }
-  if (packageManager === "bun") {
-    return {
-      command: "bun",
-      args: [
-        "install",
-        "-g",
-        ...(skipScripts ? ["--ignore-scripts"] : []),
-        packageName
-      ]
-    };
-  }
-  throw new Error(`Unsupported package manager: ${packageManager}`);
-}
-
-function getPackageManagerInstallHelp(platform = getPlatform()) {
+function getNpmInstallHelp(platform = getPlatform()) {
   const platformLabel = {
     darwin: "macOS",
     win32: "Windows",
@@ -168,32 +52,12 @@ function getPackageManagerInstallHelp(platform = getPlatform()) {
   };
 }
 
-function getAvailablePackageManagers() {
-  return ["bun", "npm"].filter((packageManager) => commandExists(packageManager));
-}
-
-function getBunGlobalBinDir(availablePackageManagers = getAvailablePackageManagers()) {
-  if (!availablePackageManagers.includes("bun")) {
-    return undefined;
-  }
-  return readCommandOutput("bun", ["pm", "bin", "-g"]) || join(home, ".bun", "bin");
-}
-
-function getNpmGlobalPrefix(availablePackageManagers = getAvailablePackageManagers()) {
-  if (!availablePackageManagers.includes("npm")) {
-    return undefined;
-  }
-  return readCommandOutput("npm", ["prefix", "-g"]);
-}
-
 async function installCliTool(tool, { confirmOrCancel }) {
   const toolConfig = {
     claude: {
       label: "Claude Code",
       command: "claude",
-      packageName: "@anthropic-ai/claude-code",
-      supportedPackageManagers: ["npm"],
-      installRequirement: "Claude Code 安装需要执行 postinstall；Bun 默认会阻止该脚本，因此需使用 npm。"
+      packageName: "@anthropic-ai/claude-code"
     },
     codex: {
       label: "Codex",
@@ -208,44 +72,21 @@ async function installCliTool(tool, { confirmOrCancel }) {
     }
   }[tool];
 
-  if (!toolConfig) {
-    throw new Error(`Unsupported tool: ${tool}`);
-  }
-
-  const commandPath = getCommandPath(toolConfig.command);
-  const installed = Boolean(commandPath);
-  const availablePackageManagers = getAvailablePackageManagers();
-  const packageManagerChoice = chooseCliInstallPackageManager({
-    commandPath,
-    availablePackageManagers,
-    bunGlobalBinDir: getBunGlobalBinDir(availablePackageManagers),
-    npmGlobalPrefix: getNpmGlobalPrefix(availablePackageManagers),
-    platform: getPlatform(),
-    nodeAvailable: commandExists("node"),
-    supportedPackageManagers: toolConfig.supportedPackageManagers
-  });
+  if (!toolConfig) throw new Error(`Unsupported tool: ${tool}`);
 
-  if (!packageManagerChoice.packageManager) {
-    const help = getPackageManagerInstallHelp();
-    p.log.warn(`未检测到可用于安装 ${toolConfig.label} 的包管理器。`);
-    if (packageManagerChoice.source === "missing-node") {
-      p.log.message(`${toolConfig.label} 是 Node CLI；使用 Bun 安装前也需要先安装 Node.js。`);
-    }
-    if (toolConfig.installRequirement) {
-      p.log.message(toolConfig.installRequirement);
-    }
+  if (!commandExists("npm")) {
+    const help = getNpmInstallHelp();
+    p.log.warn(`未检测到 npm，无法安装 ${toolConfig.label}。`);
     p.log.message(`${help.platformLabel} 可先安装 Node.js/npm，再重新运行安装。`);
     p.log.message(`中国大陆镜像: ${help.mainlandUrl}`);
     p.log.message(`官方下载页: ${help.officialUrl}`);
     return;
   }
 
+  const installed = commandExists(toolConfig.command);
   if (installed) {
-    const managerMessage = packageManagerChoice.source === "existing"
-      ? `检测到原安装方式为 ${packageManagerChoice.packageManager}`
-      : `未识别原安装方式，将使用 ${packageManagerChoice.packageManager}`;
     const shouldUpdate = await confirmOrCancel({
-      message: `${toolConfig.label} 已检测到（${managerMessage}），是否继续安装/更新？`,
+      message: `${toolConfig.label} 已检测到，是否继续安装/更新？`,
       initialValue: false
     });
     if (!shouldUpdate) {
@@ -254,24 +95,22 @@ async function installCliTool(tool, { confirmOrCancel }) {
     }
   }
 
-  const installCommand = buildCliToolInstallCommand(packageManagerChoice.packageManager, toolConfig);
-  const s = p.spinner();
-  s.start(`正在使用 ${packageManagerChoice.packageManager} 安装 ${toolConfig.label}...`);
+  const installCommand = buildCliToolInstallCommand(toolConfig);
+  const spinner = p.spinner();
+  spinner.start(`正在使用 npm 安装 ${toolConfig.label}...`);
   try {
     await runCommand(installCommand.command, installCommand.args);
-    s.stop(`${toolConfig.label} 安装完成`);
-  } catch (e) {
-    s.cancel(c.red(`${toolConfig.label} 安装失败: ${e.message}`));
-    throw e;
+    spinner.stop(`${toolConfig.label} 安装完成`);
+  } catch (error) {
+    spinner.cancel(c.red(`${toolConfig.label} 安装失败: ${error.message}`));
+    throw error;
   }
 }
 
 export {
   buildCliToolInstallCommand,
-  chooseCliInstallPackageManager,
-  getPackageManagerInstallHelp,
+  getNpmInstallHelp,
   getRunCommandSpawnOptions,
-  inferPackageManagerFromCommandPath,
   installCliTool,
   commandExists
 };

package/package.json

@@ -1,29 +1,29 @@
 {
   "name": "abelworkflow",
-  "version": "1.1.2",
-  "description": "Install AbelWorkflow into ~/.agents and create Claude/Codex symlinks.",
+  "version": "1.2.0",
+  "description": "Install AbelWorkflow into ~/.agents and create Claude, Codex, and Pi links.",
   "type": "module",
   "scripts": {
-    "test": "npm run test:node",
+    "test": "npm run build && npm run test:node",
     "test:node": "node --test test/*.test.mjs",
-    "test:python": "python -m unittest discover -s test",
+    "test:python": "python -B -m unittest discover -s test",
     "test:dev-browser": "npm test --prefix skills/dev-browser",
     "test:contracts": "node --test test/runtime-doc-contracts.test.mjs test/cli-args.test.mjs",
     "typecheck": "npm run typecheck --prefix skills/dev-browser",
     "build": "npm run build --prefix skills/dev-browser",
     "prepack": "npm run build",
     "check:docs": "node --test test/docs-contracts.test.mjs test/runtime-doc-contracts.test.mjs",
-    "check:package": "node --test test/package-contents.test.mjs",
-    "check": "npm run build && npm run test:node && npm run test:python && npm run test:dev-browser && npm run typecheck && npm run check:docs && npm run check:package"
+    "check:package": "npm run build && node --test test/package-contents.test.mjs",
+    "check": "npm run build && npm run test:node && npm run test:python && npm run test:dev-browser && npm run typecheck"
   },
   "bin": {
     "abelworkflow": "bin/abelworkflow.mjs"
   },
   "files": [
     "bin",
+    "extensions",
     "lib",
     "README.md",
-    "extensions",
     "skills/context7-auto-research/.env.example",
     "skills/context7-auto-research/SKILL.md",
     "skills/context7-auto-research/context7-api.cjs",
@@ -36,11 +36,9 @@
     "skills/grok-search/.env.example",
     "skills/grok-search/SKILL.md",
     "skills/grok-search/defaults.json",
-    "skills/grok-search/gitignore.template",
     "skills/grok-search/requirements.txt",
     "skills/grok-search/scripts/_dotenv.py",
     "skills/grok-search/scripts/groksearch_cli.py",
-    "skills/grok-search/scripts/groksearch_entry.py",
     "skills/prompt-enhancer/SKILL.md",
     "skills/prompt-enhancer/TEMPLATE.md",
     "skills/time/SKILL.md",