feat(#1169): complete ADR-857 phase 6 — migrate features to Capabilities, revive dead gates, harden conformance gate (#1183)
* test(#1168): make phase-6 gate un-gameable — reject empty stubs + require loop shrink The migration assertion previously checked only role==feature, so a registration-only stub (empty hooks, logic left inline) would turn the gate green while phase 6 stayed incomplete — the exact false-completion pattern this gate exists to prevent. Strengthen it: each ADR-named feature must OWN its behavior (>=1 hook, or a command family); and plan-phase.md/execute-phase.md must shrink strictly below their frozen pre-phase-6 sizes (94519/93166 LF bytes), which also defeats double-run gaming (declare a hook but keep the inline block -> file does not shrink -> red). Gate now 5 pass / 4 fail (orphaned execute:wave:post, empty/unregistered features, config-key leaks, no shrink). Green is now reachable only by REAL migration. Refs #1168, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): migrate gap-analysis to a Capability (plan:post gate) First real ADR-857 phase-6 migration (pattern-defining tracer). gap-analysis moves from an inline post_planning_gaps branch in plan-phase.md to a real plan:post gate Capability: - capabilities/gap-analysis/capability.json: role:feature, plan:post gate (when=workflow.post_planning_gaps, blocking:false advisory), OWNS workflow.post_planning_gaps (federated out of central schema). - plan-phase.md: inline config-get + gsd_run gap-analysis block replaced with a plan:post render-hooks call site dispatching the gate; file shrinks 94519->93279. - src/check-command-router.cts: cmdGapAnalysisPlanPost runs the real gap analysis via gap-checker. - post_planning_gaps removed from central manifest; resolves via federated config (default true preserved). - tests/post-planning-gaps-2493: re-pointed to assert capability ownership. Verified: gate 5 pass / 4 fail (gap-analysis cleared from migration, plan:post-orphan, config-leak, and plan-phase shrink checks); loadConfig still returns post_planning_gaps=true; check command runs real analysis; 392/392 in the config/registry/federation/router net. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): migrate profile-pipeline to a command-family Capability ADR-857 Decision 7: profile-pipeline becomes a command-family Capability (like audit/intel/graphify). capabilities/profile-pipeline/capability.json declares an 8-command family (scan-sessions, extract-messages, profile-sample, write-profile, profile-questionnaire, generate-dev-preferences, generate-claude-profile, generate-claude-md) backed by a new gsd-core/bin/lib/profile-pipeline-command-router.cjs; the inline case arms are removed from gsd-tools.cjs. Owns profile-pipeline.enabled (federated). Verified: registry shows role:feature with commands.length=8; scan-sessions/profile-sample run live via the family; gate cleared profile-pipeline from the empty-stub failure (only tdd/schema-gate/drift remain); 296/296 registry+inventory+gsd-tools tests; lint 0 errors. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1167): wire execute:wave:post + implement ui.safety-gate check Revives the second dead gate from #1167: ui.gates@execute:wave:post was declared but never dispatched AND its check.query (ui.safety-gate) was unimplemented. Adds the per-wave execute:wave:post render-hooks call site in execute-phase.md (fires after each wave's merge/cleanup, before the next forks) and implements cmdUiSafetyGate (frontend + UI-SPEC aware, mirrors cmdUiPlanGate) in check-command-router. +17 regression tests. Verified: phase-6 orphaned-points conformance test now PASSES (gate 6 pass / 3 fail); ui-safety-gate routable in dot+hyphen forms; check-ui-safety-gate 17/17, check-ui-plan-gate 18/18; lint 0 errors. Refs #1167, #1168. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): migrate drift (schema + codebase) to execute:wave:post gates Removes the inline schema_drift_gate + codebase_drift_gate steps (77 lines) from execute-phase.md; drift becomes a Capability with two execute:wave:post gates (verify.schema-drift blocking, verify.codebase-drift advisory) dispatched via the per-wave render-hooks call site. check-command-router routes verify.schema-drift / verify.codebase-drift to the real detectors. Federates workflow.drift_threshold / drift_action / schema_drift_gate out of central. Also fixes the execute:wave:post dispatch prose to run NON-blocking (advisory) gates too — the prior version only ran blocking gates, which would have silently dropped the codebase-drift advisory after its inline step was removed. Behavior preserved. Verified: gate 7 pass / 2 fail (drift cleared from stub + config-leak; execute-phase.md 92297 < 93166 frozen -> shrink passes); both drift checks run real detection; loadConfig defaults preserved (threshold=3, action=warn, gate=true); drift-detection 56/56 + schema-drift 34/34; lint 0 errors. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): migrate tdd to a Capability (plan:pre contribution + execute:post gate) tdd becomes a real Capability: a plan:pre contribution injects the <tdd_mode_active> planner guidance (rendered from PLAN_PRE_HOOKS_JSON like security's contribution), and an execute:post gate (tdd.review-checkpoint, advisory) runs the real end-of-phase RED/GREEN review via a new check-command handler. Inline tdd_mode reads + the inline planner block + the tdd_review_checkpoint step are removed; workflow.tdd_mode is federated out of central. The MVP+TDD per-task RED-commit gate is preserved — TDD_MODE is now derived from the execute:post hooks (capId==tdd active), not an inline config-get. BEHAVIOR CHANGE (documented, not silent): the --tdd CLI flag now persists workflow.tdd_mode=true via config-set instead of being per-invocation. Rationale: tdd is now a config-toggled Capability, and env vars do not persist across the workflow's separate bash blocks (config does), so an ephemeral override isn't cleanly achievable; --tdd therefore enables the tdd capability, consistent with how all capabilities are toggled. Verified: gate 7 pass / 2 fail (tdd cleared from stub + config-leak; plan-phase + execute-phase both < frozen sizes); contribution injection + execute:post gate dispatch wired; MVP+TDD gate preserved; tdd.review-checkpoint runs real review; full unit suite 556/0; lint 0 errors. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): migrate schema-gate to a plan:pre contribution Capability The plan-time schema-push detection (former plan-phase.md §5.7) becomes a schema-gate Capability: a plan:pre contribution (into:planner, when:workflow.schema_push_detection) whose fragment carries the full ORM-detection + [BLOCKING] schema-push-task injection logic, rendered into the planner via the existing plan:pre render-hooks dispatch. The inline §5.7 block is removed (plan-phase.md 94519->90445). workflow.schema_push_detection is a new capability-owned (federated) key, default true. (The execute-side schema-drift gate was migrated separately into the drift capability.) Verified: registry inlines the fragment (len 2704) so it is actually delivered at plan:pre; gate 8 pass / 1 fail — all 5 ADR-named features now real Capabilities, only the config-leak test remains (intel/security, next unit). Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * feat(#1169): close the 3 capability config-key leaks — phase-6 gate now GREEN Removes the last inline config-get reads of capability-owned keys from plan-phase.md. security_asvs_level/security_block_on now flow through the security plan:pre contribution via a new loop-resolver configValues mechanism (resolves declared config keys with the same 4-level precedence as activation and attaches them to the rendered hook); the §5.55 banner reads them from PLAN_PRE_HOOKS_JSON. intel.enabled becomes a real intel plan:pre step (ref.command: intel api-surface) dispatched via render-hooks; the inline intel branch is gone. gen-capability-registry now validates ref.command as a third dispatch shape. Verified: phase-6 capstone conformance gate is FULLY GREEN (9/0); 3 leaks gone (grep=0); security configValues resolve to {2,medium}/default {1,high}; intel step present only when enabled; loop-render-hooks 62/0, capability-registry 287/0, capability-state/federated-config 113/0; lint 0 errors. Closes the migration half of #1169. Refs #1139, #1167, #1168. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): address adversarial review — restore schema-drift block, generic planner injection, uniform gate contract Adversarial review caught 2 real regressions the green gate missed: (1) schema-drift no longer blocked — the execute:wave:post dispatch read GATE_RESULT.block but verify.schema-drift emitted drift_detected/blocking, and onError:skip wrongly bypassed positive blocks; (2) only tdd's plan:pre contribution was injected into the planner, dropping schema-gate's schema-push detection and security's threat-model guidance. Fixes: (A) every gate check returns a uniform boolean 'block' under --raw (the dispatch form), with advisory gates (tdd/gap) carrying their report in 'message'; (B) gate-dispatch contract corrected at all sites — onError governs command errors only, a blocking gate's positive block always halts; (C) generic planner injection of all plan:pre contributions where into=='planner' (tdd + schema-gate + security incl configValues); (D) two new conformance assertions: planner contributions injected generically + every gate check.query returns boolean block under --raw. Verified: gate 11/11; all 6 gate checks return boolean block under --raw; full suite 595/0; lint 0 errors. Refs #1167, #1168, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): restore MVP+TDD end-of-phase blocking escalation (2nd adversarial pass) The migrated tdd execute:post gate is statically blocking:false, but the contract (references/execute-mvp-tdd.md + CONTEXT.md) requires the end-of-phase TDD review to ESCALATE from advisory to blocking when MVP_MODE && TDD_MODE && a TDD plan misses a RED/GREEN commit. The migration prose had downgraded this to a 'strong advisory recommendation' — silent loss of the blocking escalation. Restore it: the tdd-gate dispatch now refuses to mark the phase complete (Phase blocked message) under MVP+TDD when GATE_RESULT.block is true; advisory otherwise. Also strengthen tests/execute-mvp-tdd-gate.test.cjs: hasBlockingEscalation previously matched any line with 'blocking'+'mvp+tdd' (so 'advisory (blocking: false) ... under MVP+TDD' was a false green); now it requires the real refusal semantics ('refuse to mark the phase complete' / 'phase blocked'). Caught by 2nd adversarial review pass. Verified: execute-phase.md 92702 < 93166 frozen; mvp-tdd-gate + phase-6 gate 19/0; full suite green; lint 0 errors. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): restore MVP+TDD proceed-block, codebase auto-remap, schema skip-flag (3rd adversarial pass) 3rd adversarial pass found 4 more silent regressions: (1) the tdd MVP+TDD 'refuse to mark complete' was nullified by a downstream 'ALWAYS proceed regardless of gate results' line — proceed is now conditional (stops on an active MVP+TDD block); (2) the test now asserts the proceed is NOT an unconditional override; (3) codebase-drift auto-remap (spawn gsd-codebase-mapper when drift_action=auto-remap) was dropped — the execute:wave:post advisory dispatch now consumes spawn_mapper/directive; (4) GSD_SKIP_SCHEMA_CHECK bypass was lost from the gate path — cmdVerifySchemaDrift now honors the env var (block:false when set). Verified: no unconditional proceed; GSD_SKIP_SCHEMA_CHECK=true -> block:false; gate 11/11 + mvp-tdd 9/9; full suite 569/0; lint 0; execute-phase.md 93109 < 93166. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): init.cts reads federated config keys from nested path (4th adversarial pass) Config federation moved tdd_mode/research/nyquist_validation from flat config.<key> to nested config.workflow.<key>, but src/init.cts still read them flat — so init.plan-phase/init.execute-phase emitted tdd_mode:false / research_enabled:undefined / nyquist:undefined regardless of config (a public command-contract regression; the migrated loops use render-hooks so enforcement was unaffected). Read via config.workflow (type-safe Record cast). Now init reflects the same resolved values + federated defaults (research/nyquist default true) as the render-hooks path. Verified: build clean; init.plan-phase emits tdd_mode:true/research:false/nyquist:false for set config, defaults true for empty; full suite 591/0; lint 0. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * docs(#1169): add changeset for ADR-857 phase-6 completion (PR #1183) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): complete phase-6 migration fallout — restore TEXT_MODE, fix registry .claude leak, re-point stale workflow-contract tests The capability migration left real regressions and stale consumer tests that the per-module unit suite missed but the full cross-platform suite caught (27 failing tests): Real source regressions (fixed): - execute-phase.md lost its AskUserQuestion TEXT_MODE plain-text fallback when the inline schema_drift_gate step was removed — non-Claude runtimes would stall. Restored, and the execute:post gate-dispatch prose de-duplicated to cite the execute:wave:post contract (loop body shrinks below the frozen pre-phase-6 ceiling while keeping every onError/blocking nuance). - capabilities/tdd inline fragment hardcoded `@~/.claude/gsd-core/references/tdd.md`, baked verbatim into the committed capability-registry.cjs and leaked the install path on 11 non-Claude runtimes (registry .cjs is copied, not path-converted). Made the fragment path-free; regenerated the registry. The phase-6 conformance gate now guards this (no ~/.claude install path in any capability source or the generated registry). - plan-phase.md: removed a §5.7 stub re-added in error and routed Branch 2 to step 6 (schema-gate is a plan:pre capability, §5.7 is gone). Stale workflow-contract tests re-pointed to the capability dispatch they now must assert (behavior verified preserved in source first, assertions kept equal-or-stronger): bug-621 + bug-2851 (gap-analysis via gsd_run render-hooks plan:post + registry binding), feat-2527 (tdd_mode federated out of central), phase6-planning + plan-phase-ui-redirect (§5.6 bounded by ## 6.), plan-phase-drift-guard (intel when:intel.enabled skip branch). profile-pipeline-command-router.cjs un-ignored from eslint (hand-written, no TS source) + stale disable comments removed. Size baseline regenerated. Verified: full suite 15140 tests / 0 fail; lint 0 errors; conformance gate green legitimately. Refs #1139, #1167, #1168, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * test(#1169): add ADR-857 E2E content-test coverage for the 12 loop points + capability deliverables Grounds the capability engine in behavioral E2E tests (drive the real render-hooks/check CLI + the real registry, assert typed result content — no source-grep), structured around what ADR-857 says to deliver. 207 tests; each genuineness-checked (flip the expectation, confirm it fails). Per-loop-point dispatch (7 files): empty-point negative-space across the 6 no-hook points; verify:post 3-step resolution+ordering+onError; plan:pre contribution/configValues + ui.plan-gate + intel; plan:post gap-analysis; execute:wave:post drift+ui gates via the check route (schema-drift block/skip, codebase-drift threshold BVA, auto-remap); execute:post tdd.review-checkpoint RED/GREEN; ship:pre security gate resolution + frontmatter-get predicate pieces. ADR-deliverable coverage (4 files): predicate boundary held (edge/prohibition probes stay core, not off-by-default Feature Capabilities — phase-6 exception); core loop runs with zero capabilities (all 12 points empty, init bundles resolve); contribution merge (multiple ordered <contribution from=> blocks); federated-config key removal on uninstall. federated-config allowlisted for its 3-file split (unit + integration + lifecycle). Refs #1139, #1167, #1168, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): remove dead drifted converter dups + address adversarial review Lint cleanup (root-caused, not waved off): src/runtime-artifact-conversion.cts carried 11 agent-converter functions (+5 orphaned consts/helpers) that were never exported, never called, and had silently DRIFTED from the live hand-authored copies in bin/install.js (one even referenced an undefined `claudeToCopilotTools`). Deleted the dead duplicates; install.js's live copies are untouched (it never imported these). Lint now 0 errors / 0 warnings. Adversarial-review (Codex) findings fixed: - HIGH: execute-phase.md TDD_MODE used `jq ... || echo false`, silently disabling the MVP+TDD blocking gate on jq-less runtimes. Reverted to the `node -e` form (node is guaranteed; matches the file's other node-e usages) so a missing optional tool can no longer fail-open a blocking safety path. - MEDIUM: federated-config-key-removal orphan-key test was vacuous (it skipped the orphan assertion). Now asserts the removed capability's key is genuinely not surfaced/validated after uninstall. - LOW: phase-6 conformance leak regex broadened to catch absolute-home and Windows-backslash `.claude/(gsd-core|commands|agents|hooks)` paths, not only `~`/`$HOME` forward-slash forms. - LOW: bug-2851 plan:post dispatch assertion now requires `--raw` (matched its stated contract). - nit: plan-pre intel-step test duplicate assertion replaced with a distinct structured-output check. Size baseline regenerated (execute-phase.md 93089 < 93166 frozen). Refs #1167, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * test(#1169): make runtime-homes-descriptor-drive titles environment-independent The descriptor-equivalence test embedded the absolute golden config path (`os.homedir()`-derived) directly in each `test(...)` title, so titles differed between macOS (`/Users/x/.claude`) and Docker (`/home/gsdtest/.claude`). Every test PASSES on both platforms (15885/0 leaf tests each), but gsd-test-summary compares results by title and reported 29+29 false "only in Mac / only in Docker" discrepancies for tests that actually pass everywhere. Move the golden path out of the title and into the assertion message (still shown on failure); titles are now byte-identical across platforms so the cross-platform comparator matches them. No assertion logic or golden values changed. Refs #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(#1169): derive TDD_MODE via gsd_run --active-cap, not node -e (fix prompt-injection CI gate) The prior fix reverted execute-phase.md:181 from jq to `node -e` to close a Codex HIGH (jq||echo-false silently disabling the MVP+TDD blocking gate on jq-less runtimes) — but the CI prompt-injection scanner BLOCKS new `node -e` in workflow markdown (inline code-exec = injection vector), turning the security gate red. Both forms were wrong: node -e fails the scanner; jq fail-opens a blocking safety gate; `config-get workflow.tdd_mode` is forbidden by the conformance leak gate (tdd_mode is capability-owned). Correct fix (what Codex recommended): a gsd_run-native boolean. Add an `--active-cap <capId>` flag to `loop render-hooks <point>` that resolves hooks the normal way and prints exactly `true`/`false` for whether a capId is active — scanner-safe (canonical launcher, no inline code), node-reliable (no optional jq to fail-open), and leak-free (render-hooks resolution, not config-get). execute-phase.md:181 now `TDD_MODE=$(gsd_run loop render-hooks execute:post --active-cap tdd)`. +5 behavioral tests for the flag. Verified: prompt-injection-scan --diff origin/next → 0 findings; conformance gate 13/13 (execute-phase.md 92934 < 93166); execute-mvp-tdd + tdd-mode + loop-render-hooks 87/0; lint 0/0. Refs #1167, #1169. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Tom Boucher
@@ -16,8 +16,14 @@ import { parseDecisions } from './decisions.cjs';
|
||||
import type { Decision } from './decisions.cjs';
|
||||
import { checkUiPresence } from './ui-safety-gate.cjs';
|
||||
// eslint-disable-next-line @typescript-eslint/no-require-imports
|
||||
import verifyModule = require('./verify.cjs');
|
||||
const { cmdVerifySchemaDrift, cmdVerifyCodebaseDrift } = verifyModule;
|
||||
// eslint-disable-next-line @typescript-eslint/no-require-imports
|
||||
import roadmapModule = require('./roadmap.cjs');
|
||||
const { getRoadmapPhaseWithFallback } = roadmapModule;
|
||||
// eslint-disable-next-line @typescript-eslint/no-require-imports
|
||||
import gapCheckerModule = require('./gap-checker.cjs');
|
||||
const { runGapAnalysis } = gapCheckerModule;
|
||||
|
||||
// ─── Helpers ──────────────────────────────────────────────────────────────────
|
||||
|
||||
@@ -462,6 +468,367 @@ function cmdUiPlanGate(projectDir: string, args: string[], raw: boolean): void {
|
||||
output(computeUiPlanGate(projectDir, phase), raw, undefined);
|
||||
}
|
||||
|
||||
// ─── ui-safety-gate ───────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* ui-safety-gate: post-wave check that verifies UI-changed files conform to
|
||||
* the active UI-SPEC for the phase. Called after each wave by execute:wave:post.
|
||||
*
|
||||
* Returns JSON: { frontend: boolean, hasUiFiles: boolean, hasUiSpec: boolean, block: boolean, message?: string }
|
||||
* block = frontend && hasUiFiles && !hasUiSpec
|
||||
*
|
||||
* Args: check ui-safety-gate <phase>
|
||||
* Invocable as: gsd_run check ui-safety-gate <phase>
|
||||
* or gsd_run check ui.safety-gate <phase> (dots normalized to hyphens)
|
||||
*
|
||||
* Uses checkUiPresence from ui-safety-gate.cjs — does NOT reimplement frontend detection.
|
||||
* Checks whether any files changed in recent git history match frontend file patterns.
|
||||
* Also checks whether a *-UI-SPEC.md exists in the phase directory (same as ui-plan-gate).
|
||||
*
|
||||
* Limitation: uses git diff HEAD~1..HEAD which covers only the last commit; in a
|
||||
* multi-plan wave the wave-start commit would be more accurate but is not yet stored
|
||||
* in the wave manifest. This is tracked as a known limitation.
|
||||
*/
|
||||
const UI_FILE_EXTENSIONS_RE = /\.(tsx|jsx|css|scss|sass|less|vue|svelte|html)$/i;
|
||||
const UI_PATH_PATTERNS_RE = /\/(components|pages|views|screens|layouts|ui|frontend)\//i;
|
||||
|
||||
/**
|
||||
* Pure logic for ui-safety-gate — exposed for direct behavioral testing.
|
||||
*
|
||||
* Given a projectDir and phase number:
|
||||
* (a) Reads the phase section from ROADMAP.md via getRoadmapPhaseWithFallback —
|
||||
* same lookup as computeUiPlanGate — to determine if this is a frontend phase.
|
||||
* (b) Runs checkUiPresence (frontend detection) — no reimplementation.
|
||||
* (c) Checks git diff HEAD~1..HEAD for UI file changes in the current worktree.
|
||||
* (d) Resolves the phase directory via core.findPhaseInternal; checks for *-UI-SPEC.md.
|
||||
*
|
||||
* Returns: { frontend, hasUiFiles, hasUiSpec, block, message?, phaseLookupFailed? }
|
||||
* block = frontend && hasUiFiles && !hasUiSpec
|
||||
* phaseLookupFailed = ROADMAP.md present but phase header not found
|
||||
*/
|
||||
function computeUiSafetyGate(projectDir: string, phase: string): {
|
||||
frontend: boolean;
|
||||
hasUiFiles: boolean;
|
||||
hasUiSpec: boolean;
|
||||
block: boolean;
|
||||
message?: string;
|
||||
phaseLookupFailed?: boolean;
|
||||
} {
|
||||
// (a) Read the phase section text (same two-pass lookup as computeUiPlanGate)
|
||||
let phaseSection = '';
|
||||
let phaseLookupFailed: boolean | undefined;
|
||||
try {
|
||||
const section = getRoadmapPhaseWithFallback(projectDir, phase);
|
||||
if (section === null) {
|
||||
const planDir: string = typeof (core as unknown as Record<string, unknown>)['planningDir'] === 'function'
|
||||
? (core as unknown as Record<string, (cwd: string) => string>)['planningDir'](projectDir)
|
||||
: path.join(projectDir, '.planning');
|
||||
const roadmapPath = path.join(planDir, 'ROADMAP.md');
|
||||
if (fs.existsSync(roadmapPath)) {
|
||||
phaseLookupFailed = true;
|
||||
}
|
||||
} else {
|
||||
phaseSection = section;
|
||||
}
|
||||
} catch { /* roadmap read failure → treat as empty (non-frontend) */ }
|
||||
|
||||
// (b) Run checkUiPresence (frontend detection) — reuse existing helper; no reimplementation
|
||||
const presenceResult = checkUiPresence(phaseSection);
|
||||
const frontend = presenceResult.hasUI;
|
||||
|
||||
// (c) Check whether any UI files were changed in recent git commits
|
||||
// Uses git diff HEAD~1..HEAD to detect frontend file changes since last commit.
|
||||
// Known limitation: multi-plan waves may need the wave-start commit for full coverage.
|
||||
let hasUiFiles = false;
|
||||
try {
|
||||
const changed = execFileSync('git', ['diff', '--name-only', 'HEAD~1', 'HEAD'], {
|
||||
cwd: projectDir,
|
||||
encoding: 'utf-8',
|
||||
maxBuffer: 2 * 1024 * 1024,
|
||||
windowsHide: true,
|
||||
});
|
||||
hasUiFiles = changed.split('\n').some((f) =>
|
||||
f.trim() && (UI_FILE_EXTENSIONS_RE.test(f) || UI_PATH_PATTERNS_RE.test(f)),
|
||||
);
|
||||
} catch { /* git unavailable or no prior commit — treat as no UI files changed */ }
|
||||
|
||||
// (d) Resolve phase directory and check for *-UI-SPEC.md (same as computeUiPlanGate)
|
||||
const coreModule = core as unknown as Record<string, unknown>;
|
||||
let phaseDir = '';
|
||||
try {
|
||||
const findPhase = coreModule['findPhaseInternal'] as ((cwd: string, phase: string) => Record<string, unknown> | string | null) | undefined;
|
||||
if (typeof findPhase === 'function') {
|
||||
const result = findPhase(projectDir, phase);
|
||||
if (result && typeof result === 'object') {
|
||||
const relDir = typeof result['directory'] === 'string' ? result['directory'] : '';
|
||||
if (relDir) {
|
||||
phaseDir = path.resolve(projectDir, relDir);
|
||||
}
|
||||
} else if (typeof result === 'string') {
|
||||
phaseDir = result;
|
||||
}
|
||||
}
|
||||
} catch { /* phase dir lookup failure → hasUiSpec=false */ }
|
||||
|
||||
const uiSpecPath = findUiSpecInDir(phaseDir);
|
||||
const hasUiSpec = uiSpecPath !== '';
|
||||
|
||||
// block only when: this is a frontend phase AND UI files were changed AND no UI-SPEC exists
|
||||
const block = frontend && hasUiFiles && !hasUiSpec;
|
||||
|
||||
const result: {
|
||||
frontend: boolean;
|
||||
hasUiFiles: boolean;
|
||||
hasUiSpec: boolean;
|
||||
block: boolean;
|
||||
message?: string;
|
||||
phaseLookupFailed?: boolean;
|
||||
} = { frontend, hasUiFiles, hasUiSpec, block };
|
||||
|
||||
if (block) {
|
||||
result.message = `UI files changed in this wave but no UI-SPEC.md exists for Phase ${phase}. ` +
|
||||
`Run /gsd:ui-phase ${phase} to generate the design contract before continuing.`;
|
||||
}
|
||||
if (phaseLookupFailed) result.phaseLookupFailed = true;
|
||||
return result;
|
||||
}
|
||||
|
||||
function cmdUiSafetyGate(projectDir: string, args: string[], raw: boolean): void {
|
||||
// args[0] = 'check', args[1] = 'ui-safety-gate', args[2] = phase
|
||||
const phase = args[2] || '';
|
||||
if (!phase) {
|
||||
error('ui-safety-gate requires a phase argument: check ui-safety-gate <phase>', ERROR_REASON.SDK_MISSING_ARG);
|
||||
return;
|
||||
}
|
||||
output(computeUiSafetyGate(projectDir, phase), raw, undefined);
|
||||
}
|
||||
|
||||
// ─── tdd-review-checkpoint ────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* tdd-review-checkpoint: end-of-phase advisory check that scans type:tdd plans
|
||||
* for RED/GREEN/REFACTOR gate-sequence compliance and surfaces a review table.
|
||||
*
|
||||
* Logic from gsd-core/references/tdd.md <end_of_phase_review> and
|
||||
* execute-phase.md <step name="tdd_review_checkpoint"> (now removed).
|
||||
*
|
||||
* Returns JSON:
|
||||
* { passed: true, tddPlans: N, violations: N, table: string, rows: PlanRow[] }
|
||||
* where passed is always true (advisory gate — never blocks).
|
||||
*
|
||||
* Args: check tdd.review-checkpoint <phase>
|
||||
* Phase can be a number or phase-dir path; if not resolvable the check
|
||||
* returns passed:true with tddPlans:0 (no plans to review).
|
||||
*/
|
||||
interface TddPlanRow {
|
||||
planId: string;
|
||||
red: boolean;
|
||||
green: boolean;
|
||||
refactor: boolean;
|
||||
status: 'Pass' | 'FAIL';
|
||||
missing: string[];
|
||||
}
|
||||
|
||||
function cmdTddReviewCheckpoint(projectDir: string, args: string[], raw: boolean): void {
|
||||
// args[0] = 'check', args[1] = 'tdd-review-checkpoint' (normalized), args[2] = phase
|
||||
const phase = args[2] || '';
|
||||
if (!phase) {
|
||||
error('tdd.review-checkpoint requires a phase argument: check tdd.review-checkpoint <phase>', ERROR_REASON.SDK_MISSING_ARG);
|
||||
return;
|
||||
}
|
||||
|
||||
// Resolve phase directory
|
||||
const coreModule = core as unknown as Record<string, unknown>;
|
||||
let phaseDir = '';
|
||||
try {
|
||||
const findPhase = coreModule['findPhaseInternal'] as ((cwd: string, phase: string) => Record<string, unknown> | string | null) | undefined;
|
||||
if (typeof findPhase === 'function') {
|
||||
const result = findPhase(projectDir, phase);
|
||||
if (result && typeof result === 'object') {
|
||||
const relDir = typeof result['directory'] === 'string' ? result['directory'] : '';
|
||||
if (relDir) phaseDir = path.resolve(projectDir, relDir);
|
||||
} else if (typeof result === 'string') {
|
||||
phaseDir = result;
|
||||
}
|
||||
}
|
||||
} catch { /* phase dir lookup failure */ }
|
||||
|
||||
// Find all PLAN.md files with type: tdd in frontmatter
|
||||
const tddPlanFiles: string[] = [];
|
||||
if (phaseDir) {
|
||||
try {
|
||||
const files = fs.readdirSync(phaseDir).filter(f => f.endsWith('-PLAN.md'));
|
||||
for (const file of files) {
|
||||
const planPath = path.join(phaseDir, file);
|
||||
const content = readIfExists(planPath);
|
||||
// Check frontmatter for type: tdd
|
||||
const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
|
||||
if (frontmatterMatch) {
|
||||
const fm = frontmatterMatch[1];
|
||||
if (/^type:\s*tdd\s*$/m.test(fm)) {
|
||||
tddPlanFiles.push(planPath);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch { /* directory read failure */ }
|
||||
}
|
||||
|
||||
if (tddPlanFiles.length === 0) {
|
||||
const result = {
|
||||
// Uniform gate contract: block = violations > 0 (advisory; never truly blocks).
|
||||
block: false,
|
||||
passed: true,
|
||||
tddPlans: 0,
|
||||
violations: 0,
|
||||
table: '',
|
||||
rows: [] as TddPlanRow[],
|
||||
message: `No type:tdd plans found in phase ${phase}. TDD review skipped.`,
|
||||
};
|
||||
// Pass undefined as rawValue so --raw emits JSON (not plain text).
|
||||
// The human-readable report is carried in `result.message` for the
|
||||
// dispatch's advisory branch to surface.
|
||||
output(result, raw, undefined);
|
||||
return;
|
||||
}
|
||||
|
||||
// For each TDD plan, extract the plan ID (padded plan number) and check git log
|
||||
const rows: TddPlanRow[] = [];
|
||||
for (const planPath of tddPlanFiles) {
|
||||
// Extract plan ID from filename (e.g. "01-02-PLAN.md" → "01-02", or "03-PLAN.md" → "03")
|
||||
const basename = path.basename(planPath, '-PLAN.md');
|
||||
// planId for commit grep: phase-plan format, e.g. "01-02"
|
||||
const planId = basename;
|
||||
|
||||
// Check for RED gate commit: test({planId}):
|
||||
let red = false;
|
||||
let green = false;
|
||||
let refactor = false;
|
||||
try {
|
||||
const redCommit = execFileSync(
|
||||
'git', ['log', '--oneline', `--grep=^test(${planId}):`, '--', '.'],
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true },
|
||||
);
|
||||
red = redCommit.trim().length > 0;
|
||||
} catch { /* git unavailable or no match */ }
|
||||
|
||||
try {
|
||||
const greenCommit = execFileSync(
|
||||
'git', ['log', '--oneline', `--grep=^feat(${planId}):`, '--', '.'],
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true },
|
||||
);
|
||||
green = greenCommit.trim().length > 0;
|
||||
} catch { /* git unavailable or no match */ }
|
||||
|
||||
try {
|
||||
const refactorCommit = execFileSync(
|
||||
'git', ['log', '--oneline', `--grep=^refactor(${planId}):`, '--', '.'],
|
||||
{ cwd: projectDir, encoding: 'utf-8', maxBuffer: 1024 * 1024, windowsHide: true },
|
||||
);
|
||||
refactor = refactorCommit.trim().length > 0;
|
||||
} catch { /* git unavailable or no match */ }
|
||||
|
||||
const missing: string[] = [];
|
||||
if (!red) missing.push('RED');
|
||||
if (!green) missing.push('GREEN');
|
||||
const status: 'Pass' | 'FAIL' = missing.length === 0 ? 'Pass' : 'FAIL';
|
||||
|
||||
rows.push({ planId, red, green, refactor, status, missing });
|
||||
}
|
||||
|
||||
const violations = rows.filter(r => r.status === 'FAIL').length;
|
||||
|
||||
// Build review table
|
||||
const sep = '━'.repeat(53);
|
||||
const tableHeader = '| Plan | RED | GREEN | REFACTOR | Status |';
|
||||
const tableDivider = '|------|-----|-------|----------|--------|';
|
||||
const tableRows = rows.map(r =>
|
||||
`| ${r.planId.padEnd(4)} | ${r.red ? ' ✓ ' : ' ✗ '} | ${r.green ? ' ✓ ' : ' ✗ '} | ${r.refactor ? ' ✓ ' : ' — '} | ${r.status.padEnd(6)} |`,
|
||||
);
|
||||
|
||||
let table = [
|
||||
sep,
|
||||
` TDD REVIEW — Phase ${phase}`,
|
||||
sep,
|
||||
'',
|
||||
`TDD Plans: ${tddPlanFiles.length} | Gate violations: ${violations}`,
|
||||
'',
|
||||
tableHeader,
|
||||
tableDivider,
|
||||
...tableRows,
|
||||
].join('\n');
|
||||
|
||||
if (violations > 0) {
|
||||
table += '\n\n⚠ Gate violations are advisory — review before advancing.';
|
||||
for (const r of rows.filter(row => row.status === 'FAIL')) {
|
||||
table += `\n Plan ${r.planId} missing: ${r.missing.join(', ')} gate commit(s).`;
|
||||
table += `\n Expected commit pattern: test(${r.planId}): ... → feat(${r.planId}): ...`;
|
||||
}
|
||||
}
|
||||
|
||||
const result = {
|
||||
// Uniform gate contract: block = violations > 0.
|
||||
// This gate is advisory (blocking: false in capability.json) so block:true
|
||||
// only surfaces as a warning, never halts. Kept here so the host-loop
|
||||
// dispatch can read a single consistent `block` field.
|
||||
block: violations > 0,
|
||||
passed: true,
|
||||
tddPlans: tddPlanFiles.length,
|
||||
violations,
|
||||
table,
|
||||
rows,
|
||||
// Human-readable report in `message` so the dispatch's advisory branch
|
||||
// can surface it. --raw emits JSON (rawValue=undefined), not plain text.
|
||||
message: table,
|
||||
};
|
||||
// Pass undefined as rawValue so --raw emits JSON (not the raw table text).
|
||||
// The review table is carried in `result.message` and `result.table` so
|
||||
// the host-loop dispatch's advisory branch can surface it.
|
||||
output(result, raw, undefined);
|
||||
}
|
||||
|
||||
// ─── gap-analysis-plan-post ───────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* gap-analysis-plan-post: non-blocking advisory check that runs the post-planning
|
||||
* gap analysis after all PLAN.md files are generated for a phase.
|
||||
*
|
||||
* Cross-references every REQ-ID and D-ID from REQUIREMENTS.md and CONTEXT.md
|
||||
* against the concatenated text of all *-PLAN.md files, emitting a coverage table.
|
||||
*
|
||||
* This gate is always advisory (passed: true) — it never blocks phase advancement.
|
||||
*
|
||||
* Args: check gap-analysis.plan-post <phase-dir> [phase-req-ids]
|
||||
* Invocable as: gsd_run check gap-analysis.plan-post <phase-dir> [phase-req-ids]
|
||||
*/
|
||||
function cmdGapAnalysisPlanPost(projectDir: string, args: string[], raw: boolean): void {
|
||||
// args[0] = 'check', args[1] = 'gap-analysis-plan-post' (normalized), args[2] = phaseDir, args[3] = phaseReqIds
|
||||
const phaseDir = args[2] || '';
|
||||
if (!phaseDir) {
|
||||
error('gap-analysis.plan-post requires a phase-dir argument: check gap-analysis.plan-post <phase-dir> [phase-req-ids]', ERROR_REASON.SDK_MISSING_ARG);
|
||||
return;
|
||||
}
|
||||
const phaseReqIds = args[3] ?? undefined;
|
||||
const result = runGapAnalysis(projectDir, phaseDir, { phaseReqIds });
|
||||
// Uniform gate contract: block = false (gap-analysis is always advisory, never blocks).
|
||||
// `message` carries the human-readable gap analysis report so the dispatch's
|
||||
// advisory branch can surface it. --raw emits JSON (rawValue=undefined), not
|
||||
// plain markdown text.
|
||||
output(
|
||||
{
|
||||
block: false,
|
||||
passed: true,
|
||||
enabled: result.enabled,
|
||||
table: result.table,
|
||||
summary: result.summary,
|
||||
counts: result.counts,
|
||||
// Human-readable report in `message` for the host-loop advisory branch.
|
||||
message: result.table || result.summary || '',
|
||||
},
|
||||
raw,
|
||||
undefined,
|
||||
);
|
||||
}
|
||||
|
||||
interface RouteCheckCommandOptions {
|
||||
args: string[];
|
||||
cwd: string;
|
||||
@@ -493,7 +860,34 @@ function routeCheckCommand({ args, cwd, raw }: RouteCheckCommandOptions): void {
|
||||
cmdUiPlanGate(cwd, args, raw);
|
||||
return;
|
||||
}
|
||||
error('Unknown check subcommand. Available: auto-mode, decision-coverage-plan, decision-coverage-verify, ui-plan-gate', ERROR_REASON.SDK_UNKNOWN_COMMAND);
|
||||
if (subcommand === 'gap-analysis-plan-post') {
|
||||
cmdGapAnalysisPlanPost(cwd, args, raw);
|
||||
return;
|
||||
}
|
||||
if (subcommand === 'tdd-review-checkpoint') {
|
||||
cmdTddReviewCheckpoint(cwd, args, raw);
|
||||
return;
|
||||
}
|
||||
if (subcommand === 'ui-safety-gate') {
|
||||
cmdUiSafetyGate(cwd, args, raw);
|
||||
return;
|
||||
}
|
||||
if (subcommand === 'verify-schema-drift') {
|
||||
// Delegates to verify.schema-drift — drift capability gate at execute:wave:post (blocking).
|
||||
// Dot-to-hyphen normalization means query "verify.schema-drift" routes here.
|
||||
// Honor GSD_SKIP_SCHEMA_CHECK=true to bypass the gate (preserves the original inline gate behavior).
|
||||
const phaseArg = typeof args[2] === 'string' ? args[2] : '';
|
||||
const skipSchemaCheck = process.env['GSD_SKIP_SCHEMA_CHECK'] === 'true';
|
||||
cmdVerifySchemaDrift(cwd, phaseArg, skipSchemaCheck, raw);
|
||||
return;
|
||||
}
|
||||
if (subcommand === 'verify-codebase-drift') {
|
||||
// Delegates to verify.codebase-drift — drift capability gate at execute:wave:post (non-blocking).
|
||||
// Dot-to-hyphen normalization means query "verify.codebase-drift" routes here.
|
||||
cmdVerifyCodebaseDrift(cwd, raw);
|
||||
return;
|
||||
}
|
||||
error('Unknown check subcommand. Available: auto-mode, decision-coverage-plan, decision-coverage-verify, gap-analysis-plan-post, tdd-review-checkpoint, ui-plan-gate, ui-safety-gate, verify-schema-drift, verify-codebase-drift', ERROR_REASON.SDK_UNKNOWN_COMMAND);
|
||||
}
|
||||
|
||||
export = {
|
||||
@@ -501,4 +895,7 @@ export = {
|
||||
decisionMentioned,
|
||||
extractPlanDesignatedSections,
|
||||
computeUiPlanGate,
|
||||
computeUiSafetyGate,
|
||||
cmdGapAnalysisPlanPost,
|
||||
cmdTddReviewCheckpoint,
|
||||
};
|
||||
|
||||
@@ -576,7 +576,6 @@ function loadConfig(cwd: string, options: Record<string, unknown> = {}): Record<
|
||||
brave_search: get('brave_search') ?? defaults.brave_search,
|
||||
firecrawl: get('firecrawl') ?? defaults.firecrawl,
|
||||
exa_search: get('exa_search') ?? defaults.exa_search,
|
||||
tdd_mode: get('tdd_mode', { section: 'workflow', field: 'tdd_mode' }) ?? false,
|
||||
mvp_mode: get('mvp_mode', { section: 'workflow', field: 'mvp_mode' }) ?? false,
|
||||
text_mode: get('text_mode', { section: 'workflow', field: 'text_mode' }) ?? defaults.text_mode,
|
||||
auto_advance: get('auto_advance', { section: 'workflow', field: 'auto_advance' }) ?? false,
|
||||
|
||||
@@ -235,7 +235,6 @@ function buildNewProjectConfig(userChoices: Record<string, unknown>): Record<str
|
||||
ui_phase: true,
|
||||
ui_safety_gate: true,
|
||||
ai_integration_phase: true,
|
||||
tdd_mode: false,
|
||||
human_verify_mode: 'end-of-phase',
|
||||
text_mode: false,
|
||||
research_before_questions: false,
|
||||
|
||||
16
src/init.cts
16
src/init.cts
@@ -229,11 +229,13 @@ function cmdInitExecutePhase(
|
||||
: null;
|
||||
const phase_req_ids = reqExtracted && reqExtracted !== 'TBD' ? reqExtracted : null;
|
||||
|
||||
const wf = (config.workflow ?? {}) as Record<string, unknown>;
|
||||
|
||||
const result: Record<string, unknown> = {
|
||||
executor_model: resolveModelInternal(cwd, 'gsd-executor'),
|
||||
verifier_model: resolveModelInternal(cwd, 'gsd-verifier'),
|
||||
|
||||
tdd_mode: options['tdd'] || config.tdd_mode || false,
|
||||
tdd_mode: options['tdd'] || Boolean(wf['tdd_mode']) || false,
|
||||
commit_docs: config.commit_docs,
|
||||
sub_repos: config.sub_repos,
|
||||
parallelization: config.parallelization,
|
||||
@@ -381,16 +383,18 @@ function cmdInitPlanPhase(
|
||||
assertValidGranularityOverride(granularityOverride, error);
|
||||
const granularity = resolveGranularityInternal(cwd, 'planning', granularityOverride || undefined);
|
||||
|
||||
const wf = (config.workflow ?? {}) as Record<string, unknown>;
|
||||
|
||||
const result: Record<string, unknown> = {
|
||||
researcher_model: resolveModelInternal(cwd, 'gsd-phase-researcher'),
|
||||
planner_model: resolveModelInternal(cwd, 'gsd-planner'),
|
||||
checker_model: resolveModelInternal(cwd, 'gsd-plan-checker'),
|
||||
|
||||
tdd_mode: options['tdd'] || config.tdd_mode || false,
|
||||
tdd_mode: options['tdd'] || Boolean(wf['tdd_mode']) || false,
|
||||
granularity,
|
||||
research_enabled: config.research,
|
||||
research_enabled: wf['research'],
|
||||
plan_checker_enabled: config.plan_checker,
|
||||
nyquist_validation_enabled: config.nyquist_validation,
|
||||
nyquist_validation_enabled: wf['nyquist_validation'],
|
||||
commit_docs: config.commit_docs,
|
||||
text_mode: config.text_mode,
|
||||
auto_advance: !!(config.auto_advance),
|
||||
@@ -641,13 +645,15 @@ function cmdInitNewMilestone(cwd: string, raw: boolean): void {
|
||||
/* intentionally empty */
|
||||
}
|
||||
|
||||
const wf = (config.workflow ?? {}) as Record<string, unknown>;
|
||||
|
||||
const result: Record<string, unknown> = {
|
||||
researcher_model: resolveModelInternal(cwd, 'gsd-project-researcher'),
|
||||
synthesizer_model: resolveModelInternal(cwd, 'gsd-research-synthesizer'),
|
||||
roadmapper_model: resolveModelInternal(cwd, 'gsd-roadmapper'),
|
||||
|
||||
commit_docs: config.commit_docs,
|
||||
research_enabled: config.research,
|
||||
research_enabled: wf['research'],
|
||||
|
||||
current_milestone: milestone['version'],
|
||||
current_milestone_name: milestone['name'],
|
||||
|
||||
@@ -259,6 +259,8 @@ interface ActiveHook {
|
||||
blocking?: boolean;
|
||||
check?: unknown;
|
||||
onError?: string;
|
||||
/** Resolved capability-owned config values declared in the contribution's configValues map. */
|
||||
configValues?: Record<string, unknown>;
|
||||
}
|
||||
|
||||
interface ResolveLoopHooksInput {
|
||||
@@ -352,6 +354,47 @@ function resolveLoopHooks(input: ResolveLoopHooksInput): ResolveLoopHooksResult
|
||||
return Object.keys(fragment).length > 0 ? fragment : undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve declared configValues for a contribution hook.
|
||||
* The hook may carry `configValues: { alias: "dotted.key", ... }`.
|
||||
* Each key is resolved using the same four-level precedence as activation resolution,
|
||||
* but returning the raw value (not coerced to boolean) so numeric/string config values
|
||||
* are preserved (e.g. security_asvs_level: 2, security_block_on: "medium").
|
||||
*/
|
||||
function resolveConfigValues(hook: RawHook): Record<string, unknown> | undefined {
|
||||
const raw = (hook as Record<string, unknown>)['configValues'];
|
||||
if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
|
||||
const rawMap = raw as Record<string, unknown>;
|
||||
const resolved: Record<string, unknown> = {};
|
||||
for (const [alias, dotKey] of Object.entries(rawMap)) {
|
||||
// Prototype-pollution guard (inline literal, CodeQL barrier)
|
||||
if (alias === '__proto__' || alias === 'constructor' || alias === 'prototype') continue;
|
||||
if (typeof dotKey !== 'string') continue;
|
||||
// Level 1: loadConfig result
|
||||
const fromConfig = _getNestedConfigValue(config, dotKey);
|
||||
if (fromConfig.found) { resolved[alias] = fromConfig.value; continue; }
|
||||
// Level 2 + 3: raw config.json files
|
||||
if (cwd) {
|
||||
const wsConfigPath = path.join(planningDir(cwd), 'config.json');
|
||||
const rootConfigPath = path.join(planningRoot(cwd), 'config.json');
|
||||
const fromWs = _readRawConfigKey(wsConfigPath, dotKey);
|
||||
if (fromWs.found) { resolved[alias] = fromWs.value; continue; }
|
||||
if (wsConfigPath !== rootConfigPath) {
|
||||
const fromRoot = _readRawConfigKey(rootConfigPath, dotKey);
|
||||
if (fromRoot.found) { resolved[alias] = fromRoot.value; continue; }
|
||||
}
|
||||
}
|
||||
// Level 4: registry configSchema default
|
||||
const schemaEntry = (registry['configSchema'] as Record<string, unknown> | undefined)?.[dotKey];
|
||||
if (schemaEntry && typeof schemaEntry === 'object' && schemaEntry !== null) {
|
||||
const def = (schemaEntry as Record<string, unknown>)['default'];
|
||||
if (def !== undefined) { resolved[alias] = def; continue; }
|
||||
}
|
||||
// Level 5: absent → undefined (omit from resolved map)
|
||||
}
|
||||
return Object.keys(resolved).length > 0 ? resolved : undefined;
|
||||
}
|
||||
|
||||
// Process steps
|
||||
const stepsRaw = entryMap['steps'];
|
||||
const steps: RawHook[] = Array.isArray(stepsRaw) ? (stepsRaw as RawHook[]) : [];
|
||||
@@ -392,6 +435,7 @@ function resolveLoopHooks(input: ResolveLoopHooksInput): ResolveLoopHooksResult
|
||||
const produces = toStringArray(hook['produces']);
|
||||
const consumes = toStringArray(hook['consumes']);
|
||||
const onError = typeof hook['onError'] === 'string' ? hook['onError'] : undefined;
|
||||
const configValuesResolved = resolveConfigValues(hook);
|
||||
const active: ActiveHook = { capId, kind: 'contribution' };
|
||||
if (into !== undefined) active.into = into;
|
||||
if (fragment !== undefined) active.fragment = fragment;
|
||||
@@ -399,6 +443,7 @@ function resolveLoopHooks(input: ResolveLoopHooksInput): ResolveLoopHooksResult
|
||||
if (produces.length > 0) active.produces = produces;
|
||||
if (consumes.length > 0) active.consumes = consumes;
|
||||
if (onError !== undefined) active.onError = onError;
|
||||
if (configValuesResolved !== undefined) active.configValues = configValuesResolved;
|
||||
activeHooks.push(active);
|
||||
}
|
||||
|
||||
@@ -535,6 +580,13 @@ function renderLoopHooks(resolved: ResolveLoopHooksResult): string {
|
||||
* merged-object-from-untrusted-keys security concern and correctly handles
|
||||
* pre-cutover keys like `workflow.ui_phase` that live in config.json but are not
|
||||
* yet exposed through loadConfig's whitelist.
|
||||
*
|
||||
* --active-cap <capId>: when present, resolves hooks for <point> exactly as the
|
||||
* normal path does, then prints exactly `true` (if any resolved activeHook has
|
||||
* capId === <capId>) or `false` followed by a single newline, and exits 0.
|
||||
* No JSON envelope is emitted — output is clean for shell $(…) capture.
|
||||
* Missing <capId> value → coreError + non-zero exit.
|
||||
* Unknown/inactive capId → `false` (not an error).
|
||||
*/
|
||||
function cmdLoopRenderHooks(
|
||||
cwd: string,
|
||||
@@ -547,6 +599,13 @@ function cmdLoopRenderHooks(
|
||||
return;
|
||||
}
|
||||
|
||||
// --active-cap <capId> mode: emit 'true' or 'false' only (scanner-safe, no JSON envelope)
|
||||
const activeCapId = typeof options['activeCap'] === 'string' ? options['activeCap'] : undefined;
|
||||
if (activeCapId !== undefined && activeCapId === '') {
|
||||
coreError('--active-cap requires a <capId> value (e.g. --active-cap tdd)');
|
||||
return;
|
||||
}
|
||||
|
||||
const runtimeConfigDir = typeof options['configDir'] === 'string'
|
||||
? options['configDir']
|
||||
: undefined;
|
||||
@@ -572,6 +631,13 @@ function cmdLoopRenderHooks(
|
||||
return;
|
||||
}
|
||||
|
||||
// --active-cap mode: print exactly 'true' or 'false' with no envelope
|
||||
if (activeCapId !== undefined) {
|
||||
const isActive = resolved.activeHooks.some((h) => h.capId === activeCapId);
|
||||
process.stdout.write(isActive ? 'true\n' : 'false\n');
|
||||
return;
|
||||
}
|
||||
|
||||
const rendered = renderLoopHooks(resolved);
|
||||
const envelope: {
|
||||
point: string;
|
||||
|
||||
@@ -48,20 +48,6 @@ const claudeToOpencodeTools = {
|
||||
WebSearch: 'websearch', // Plugin/MCP - keep for compatibility
|
||||
};
|
||||
|
||||
// Tool name mapping from Claude Code to Gemini CLI
|
||||
// Gemini CLI uses snake_case built-in tool names
|
||||
const claudeToGeminiTools = {
|
||||
Read: 'read_file',
|
||||
Write: 'write_file',
|
||||
Edit: 'replace',
|
||||
Bash: 'run_shell_command',
|
||||
Glob: 'glob',
|
||||
Grep: 'search_file_content',
|
||||
WebSearch: 'google_web_search',
|
||||
WebFetch: 'web_fetch',
|
||||
TodoWrite: 'write_todos',
|
||||
};
|
||||
|
||||
// Tool name mapping from Claude/GSD agents to Kimi CLI module paths.
|
||||
// Kimi custom agent YAML requires fully-qualified module paths.
|
||||
const claudeToKimiTools = {
|
||||
@@ -109,37 +95,6 @@ function convertToolName(claudeTool) {
|
||||
return claudeTool.toLowerCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a Claude Code tool name to Gemini CLI format
|
||||
* - Applies Claude→Gemini mapping (Read→read_file, Bash→run_shell_command, etc.)
|
||||
* - Filters out MCP tools (mcp__*) — they are auto-discovered at runtime in Gemini
|
||||
* - Filters out Task/Agent — agents are auto-registered as tools in Gemini
|
||||
* @returns {string|null} Gemini tool name, or null if tool should be excluded
|
||||
*/
|
||||
function convertGeminiToolName(claudeTool) {
|
||||
// MCP tools: exclude — auto-discovered from mcpServers config at runtime
|
||||
if (claudeTool.startsWith('mcp__')) {
|
||||
return null;
|
||||
}
|
||||
// Task/Agent: exclude — agents are auto-registered as callable tools.
|
||||
// AskUserQuestion: exclude — Gemini CLI does not expose an ask_user tool;
|
||||
// emitting it causes frontmatter validation errors (#3362).
|
||||
if (
|
||||
claudeTool === 'Task' ||
|
||||
claudeTool === 'Agent' ||
|
||||
claudeTool === 'AskUserQuestion' ||
|
||||
claudeTool === 'ask_user'
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
// Check for explicit mapping
|
||||
if (claudeToGeminiTools[claudeTool]) {
|
||||
return claudeToGeminiTools[claudeTool];
|
||||
}
|
||||
// Default: lowercase
|
||||
return claudeTool.toLowerCase();
|
||||
}
|
||||
|
||||
function createKimiToolDiagnostic(reason, tool, source = null) {
|
||||
const isMcp = reason === 'mcp_managed';
|
||||
return {
|
||||
@@ -263,27 +218,6 @@ function replaceRelativePathReference(content, fromPath, toPath) {
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a Claude Code tool name to GitHub Copilot format.
|
||||
* - Applies explicit mapping from claudeToCopilotTools
|
||||
* - Handles mcp__context7__* prefix → io.github.upstash/context7/*
|
||||
* - Falls back to lowercase for unknown tools
|
||||
*/
|
||||
function convertCopilotToolName(claudeTool) {
|
||||
// mcp__context7__* wildcard → io.github.upstash/context7/*
|
||||
if (claudeTool.startsWith('mcp__context7__')) {
|
||||
return 'io.github.upstash/context7/' + claudeTool.slice('mcp__context7__'.length);
|
||||
}
|
||||
// Check explicit mapping
|
||||
if (claudeToCopilotTools[claudeTool]) {
|
||||
return claudeToCopilotTools[claudeTool];
|
||||
}
|
||||
// mcp__{tavily,ref,jina,exa,firecrawl}__* use the generic MCP passthrough like exa/firecrawl;
|
||||
// add explicit Copilot registry mappings when the io.github ids are confirmed (#657 follow-up)
|
||||
// Default: lowercase
|
||||
return claudeTool.toLowerCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply Copilot-specific content conversion — CONV-06 (paths) + CONV-07 (command names).
|
||||
* Path mappings depend on install mode:
|
||||
@@ -755,39 +689,6 @@ function buildKimiAgentArtifacts({
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a Claude agent (.md) to a Copilot agent (.agent.md).
|
||||
* Applies tool mapping + deduplication, formats tools as JSON array.
|
||||
* CONV-04: JSON array format. CONV-05: Tool name mapping.
|
||||
*/
|
||||
function convertClaudeAgentToCopilotAgent(content, isGlobal = false) {
|
||||
const converted = convertClaudeToCopilotContent(content, isGlobal);
|
||||
const { frontmatter, body } = extractFrontmatterAndBody(converted);
|
||||
if (!frontmatter) return converted;
|
||||
|
||||
const name = extractFrontmatterField(frontmatter, 'name') || 'unknown';
|
||||
const description = extractFrontmatterField(frontmatter, 'description') || '';
|
||||
const color = extractFrontmatterField(frontmatter, 'color');
|
||||
const toolsRaw = extractFrontmatterField(frontmatter, 'tools') || '';
|
||||
|
||||
// CONV-04 + CONV-05: Map tools, deduplicate, format as JSON array
|
||||
const claudeTools = toolsRaw.split(',').map(t => t.trim()).filter(Boolean);
|
||||
const mappedTools = claudeTools.map(t => convertCopilotToolName(t));
|
||||
const uniqueTools = [...new Set(mappedTools)];
|
||||
const toolsArray = uniqueTools.length > 0
|
||||
? "['" + uniqueTools.join("', '") + "']"
|
||||
: '[]';
|
||||
|
||||
// Reconstruct frontmatter in Copilot format. Quote description (#2876)
|
||||
// so a leading YAML flow indicator (`[BETA] …`, `{ … }`, etc.) doesn't
|
||||
// crash the Copilot frontmatter loader.
|
||||
let fm = `---\nname: ${name}\ndescription: ${yamlQuote(description)}\ntools: ${toolsArray}\n`;
|
||||
if (color) fm += `color: ${color}\n`;
|
||||
fm += '---';
|
||||
|
||||
return `${fm}\n${body}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply Antigravity-specific content conversion — path replacement + command name conversion.
|
||||
* Path mappings depend on install mode:
|
||||
@@ -841,32 +742,6 @@ function convertClaudeCommandToAntigravitySkill(content, skillName, _runtime = n
|
||||
return `${fm}\n${body}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a Claude agent (.md) to an Antigravity agent.
|
||||
* Uses Gemini tool names since Antigravity runs on Gemini 3 backend.
|
||||
*/
|
||||
function convertClaudeAgentToAntigravityAgent(content, isGlobal = false) {
|
||||
const converted = convertClaudeToAntigravityContent(content, isGlobal);
|
||||
const { frontmatter, body } = extractFrontmatterAndBody(converted);
|
||||
if (!frontmatter) return converted;
|
||||
|
||||
const name = extractFrontmatterField(frontmatter, 'name') || 'unknown';
|
||||
const description = extractFrontmatterField(frontmatter, 'description') || '';
|
||||
const color = extractFrontmatterField(frontmatter, 'color');
|
||||
const toolsRaw = extractFrontmatterField(frontmatter, 'tools') || '';
|
||||
|
||||
// Map tools to Gemini equivalents (reuse existing convertGeminiToolName)
|
||||
const claudeTools = toolsRaw.split(',').map(t => t.trim()).filter(Boolean);
|
||||
const mappedTools = claudeTools.map(t => convertGeminiToolName(t)).filter(Boolean);
|
||||
|
||||
// #2876: quote description for the same reason as the skill variant.
|
||||
let fm = `---\nname: ${name}\ndescription: ${yamlQuote(description)}\ntools: ${mappedTools.join(', ')}\n`;
|
||||
if (color) fm += `color: ${color}\n`;
|
||||
fm += '---';
|
||||
|
||||
return `${fm}\n${body}`;
|
||||
}
|
||||
|
||||
function toSingleLine(value) {
|
||||
return value.replace(/\s+/g, ' ').trim();
|
||||
}
|
||||
@@ -906,30 +781,6 @@ function extractFrontmatterField(frontmatter, fieldName) {
|
||||
return match[1].trim().replace(/^['"]|['"]$/g, '');
|
||||
}
|
||||
|
||||
// Tool name mapping from Claude Code to Cursor CLI
|
||||
const claudeToCursorTools = {
|
||||
Bash: 'Shell',
|
||||
Edit: 'StrReplace',
|
||||
AskUserQuestion: null, // No direct equivalent — use conversational prompting
|
||||
SlashCommand: null, // No equivalent — skills are auto-discovered
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert a Claude Code tool name to Cursor CLI format
|
||||
* @returns {string|null} Cursor tool name, or null if tool should be excluded
|
||||
*/
|
||||
function convertCursorToolName(claudeTool) {
|
||||
if (claudeTool in claudeToCursorTools) {
|
||||
return claudeToCursorTools[claudeTool];
|
||||
}
|
||||
// MCP tools keep their format (Cursor supports MCP)
|
||||
if (claudeTool.startsWith('mcp__')) {
|
||||
return claudeTool;
|
||||
}
|
||||
// Most tools share the same name (Read, Write, Glob, Grep, Task, WebSearch, WebFetch, TodoWrite)
|
||||
return claudeTool;
|
||||
}
|
||||
|
||||
function convertSlashCommandsToCursorSkillMentions(content) {
|
||||
// Keep leading "/" for slash commands; only normalize gsd: -> gsd-.
|
||||
// This preserves rendered "next step" commands like "/gsd-execute-phase 17".
|
||||
@@ -1025,53 +876,10 @@ function convertClaudeCommandToCursorCommand(content, _commandName) {
|
||||
return body.trimStart();
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert Claude Code agent markdown to Cursor agent format.
|
||||
* Strips frontmatter fields Cursor doesn't support (color, skills),
|
||||
* converts tool references, and adds a role context header.
|
||||
*/
|
||||
function convertClaudeAgentToCursorAgent(content) {
|
||||
const converted = convertClaudeToCursorMarkdown(content);
|
||||
|
||||
const { frontmatter, body } = extractFrontmatterAndBody(converted);
|
||||
if (!frontmatter) return converted;
|
||||
|
||||
const name = extractFrontmatterField(frontmatter, 'name') || 'unknown';
|
||||
const description = extractFrontmatterField(frontmatter, 'description') || '';
|
||||
|
||||
const cleanFrontmatter = `---\nname: ${yamlIdentifier(name)}\ndescription: ${yamlQuote(toSingleLine(description))}\n---`;
|
||||
|
||||
return `${cleanFrontmatter}\n${body}`;
|
||||
}
|
||||
|
||||
// --- Windsurf converters ---
|
||||
// Windsurf uses a tool set similar to Cursor.
|
||||
// Config lives in .windsurf/ (local) and ~/.codeium/windsurf/ (global).
|
||||
|
||||
// Tool name mapping from Claude Code to Windsurf Cascade
|
||||
const claudeToWindsurfTools = {
|
||||
Bash: 'Shell',
|
||||
Edit: 'StrReplace',
|
||||
AskUserQuestion: null, // No direct equivalent — use conversational prompting
|
||||
SlashCommand: null, // No equivalent — skills are auto-discovered
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert a Claude Code tool name to Windsurf Cascade format
|
||||
* @returns {string|null} Windsurf tool name, or null if tool should be excluded
|
||||
*/
|
||||
function convertWindsurfToolName(claudeTool) {
|
||||
if (claudeTool in claudeToWindsurfTools) {
|
||||
return claudeToWindsurfTools[claudeTool];
|
||||
}
|
||||
// MCP tools keep their format (Windsurf supports MCP)
|
||||
if (claudeTool.startsWith('mcp__')) {
|
||||
return claudeTool;
|
||||
}
|
||||
// Most tools share the same name (Read, Write, Glob, Grep, Task, WebSearch, WebFetch, TodoWrite)
|
||||
return claudeTool;
|
||||
}
|
||||
|
||||
function convertSlashCommandsToWindsurfSkillMentions(content) {
|
||||
// Keep leading "/" for slash commands; only normalize gsd: -> gsd-.
|
||||
return content.replace(/gsd:/gi, 'gsd-');
|
||||
@@ -1153,56 +961,10 @@ function convertClaudeCommandToWindsurfSkill(content, skillName) {
|
||||
return `---\nname: ${yamlIdentifier(skillName)}\ndescription: ${yamlQuote(shortDescription)}\n---\n\n${adapter}\n\n${body.trimStart()}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert Claude Code agent markdown to Windsurf agent format.
|
||||
* Strips frontmatter fields Windsurf doesn't support (color, skills),
|
||||
* converts tool references, and adds a role context header.
|
||||
*/
|
||||
function convertClaudeAgentToWindsurfAgent(content) {
|
||||
const converted = convertClaudeToWindsurfMarkdown(content);
|
||||
|
||||
const { frontmatter, body } = extractFrontmatterAndBody(converted);
|
||||
if (!frontmatter) return converted;
|
||||
|
||||
const name = extractFrontmatterField(frontmatter, 'name') || 'unknown';
|
||||
const description = extractFrontmatterField(frontmatter, 'description') || '';
|
||||
|
||||
const cleanFrontmatter = `---\nname: ${yamlIdentifier(name)}\ndescription: ${yamlQuote(toSingleLine(description))}\n---`;
|
||||
|
||||
return `${cleanFrontmatter}\n${body}`;
|
||||
}
|
||||
|
||||
// --- Augment converters ---
|
||||
// Augment uses a tool set similar to Cursor/Windsurf.
|
||||
// Config lives in .augment/ (local) and ~/.augment/ (global).
|
||||
|
||||
const claudeToAugmentTools = {
|
||||
Bash: 'launch-process',
|
||||
Edit: 'str-replace-editor',
|
||||
AskUserQuestion: null,
|
||||
SlashCommand: null,
|
||||
TodoWrite: 'add_tasks',
|
||||
};
|
||||
|
||||
function convertAugmentToolName(claudeTool) {
|
||||
if (claudeTool in claudeToAugmentTools) {
|
||||
return claudeToAugmentTools[claudeTool];
|
||||
}
|
||||
if (claudeTool.startsWith('mcp__')) {
|
||||
return claudeTool;
|
||||
}
|
||||
const toolMapping = {
|
||||
Read: 'view',
|
||||
Write: 'save-file',
|
||||
Glob: 'view',
|
||||
Grep: 'grep',
|
||||
Task: null,
|
||||
WebSearch: 'web-search',
|
||||
WebFetch: 'web-fetch',
|
||||
};
|
||||
return toolMapping[claudeTool] || claudeTool;
|
||||
}
|
||||
|
||||
function convertSlashCommandsToAugmentSkillMentions(content) {
|
||||
return content.replace(/gsd:/gi, 'gsd-');
|
||||
}
|
||||
@@ -1279,30 +1041,6 @@ function convertClaudeCommandToAugmentSkill(content, skillName) {
|
||||
return `---\nname: ${yamlIdentifier(skillName)}\ndescription: ${yamlQuote(shortDescription)}\n---\n\n${adapter}\n\n${body.trimStart()}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert Claude Code agent markdown to Augment agent format.
|
||||
* Strips frontmatter fields Augment doesn't support (color, skills),
|
||||
* converts tool references, and cleans up for Augment agents.
|
||||
*/
|
||||
function convertClaudeAgentToAugmentAgent(content) {
|
||||
const converted = convertClaudeToAugmentMarkdown(content);
|
||||
|
||||
const { frontmatter, body } = extractFrontmatterAndBody(converted);
|
||||
if (!frontmatter) return converted;
|
||||
|
||||
const name = extractFrontmatterField(frontmatter, 'name') || 'unknown';
|
||||
const description = extractFrontmatterField(frontmatter, 'description') || '';
|
||||
|
||||
const cleanFrontmatter = `---\nname: ${yamlIdentifier(name)}\ndescription: ${yamlQuote(toSingleLine(description))}\n---`;
|
||||
|
||||
return `${cleanFrontmatter}\n${body}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy Claude commands as Augment skills — one folder per skill with SKILL.md.
|
||||
* Mirrors copyCommandsAsCursorSkills but uses Augment converters.
|
||||
*/
|
||||
|
||||
function convertSlashCommandsToTraeSkillMentions(content) {
|
||||
return content.replace(/\/gsd:([a-z0-9-]+)/g, (_, commandName) => {
|
||||
return `/gsd-${commandName}`;
|
||||
@@ -1352,20 +1090,6 @@ function convertClaudeCommandToTraeSkill(content, skillName) {
|
||||
return `---\nname: ${yamlIdentifier(skillName)}\ndescription: ${yamlQuote(shortDescription)}\n---\n${body}`;
|
||||
}
|
||||
|
||||
function convertClaudeAgentToTraeAgent(content) {
|
||||
const converted = convertClaudeToTraeMarkdown(content);
|
||||
|
||||
const { frontmatter, body } = extractFrontmatterAndBody(converted);
|
||||
if (!frontmatter) return converted;
|
||||
|
||||
const name = extractFrontmatterField(frontmatter, 'name') || 'unknown';
|
||||
const description = extractFrontmatterField(frontmatter, 'description') || '';
|
||||
|
||||
const cleanFrontmatter = `---\nname: ${yamlIdentifier(name)}\ndescription: ${yamlQuote(toSingleLine(description))}\n---`;
|
||||
|
||||
return `${cleanFrontmatter}\n${body}`;
|
||||
}
|
||||
|
||||
function convertSlashCommandsToCodebuddySkillMentions(content) {
|
||||
return content.replace(/\/gsd:([a-z0-9-]+)/g, (_, commandName) => {
|
||||
return `/gsd-${commandName}`;
|
||||
@@ -1447,20 +1171,6 @@ function convertClaudeCommandToCodebuddyCommand(content, commandName) {
|
||||
return lines.join('\n');
|
||||
}
|
||||
|
||||
function convertClaudeAgentToCodebuddyAgent(content) {
|
||||
const converted = convertClaudeToCodebuddyMarkdown(content);
|
||||
|
||||
const { frontmatter, body } = extractFrontmatterAndBody(converted);
|
||||
if (!frontmatter) return converted;
|
||||
|
||||
const name = extractFrontmatterField(frontmatter, 'name') || 'unknown';
|
||||
const description = extractFrontmatterField(frontmatter, 'description') || '';
|
||||
|
||||
const cleanFrontmatter = `---\nname: ${yamlIdentifier(name)}\ndescription: ${yamlQuote(toSingleLine(description))}\n---`;
|
||||
|
||||
return `${cleanFrontmatter}\n${body}`;
|
||||
}
|
||||
|
||||
// ── Cline converters ────────────────────────────────────────────────────────
|
||||
|
||||
function convertClaudeToCliineMarkdown(content) {
|
||||
@@ -1485,16 +1195,6 @@ function convertClaudeToCliineMarkdown(content) {
|
||||
return converted;
|
||||
}
|
||||
|
||||
function convertClaudeAgentToClineAgent(content) {
|
||||
const converted = convertClaudeToCliineMarkdown(content);
|
||||
const { frontmatter, body } = extractFrontmatterAndBody(converted);
|
||||
if (!frontmatter) return converted;
|
||||
const name = extractFrontmatterField(frontmatter, 'name') || 'unknown';
|
||||
const description = extractFrontmatterField(frontmatter, 'description') || '';
|
||||
const cleanFrontmatter = `---\nname: ${yamlIdentifier(name)}\ndescription: ${yamlQuote(toSingleLine(description))}\n---`;
|
||||
return `${cleanFrontmatter}\n${body}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a Claude command (.md) to a Cline skill (SKILL.md).
|
||||
* Emits ONLY name + description frontmatter per the Cline skills spec
|
||||
@@ -1505,7 +1205,7 @@ function convertClaudeAgentToClineAgent(content) {
|
||||
* Cline uses Claude-Code-compatible tool names, so no adapter header is needed.
|
||||
* Targets ~/.cline/skills/<name>/SKILL.md for Cline >= v3.48.0.
|
||||
*/
|
||||
function convertClaudeCommandToClineSkill(content, skillName, runtime = null, cmdNames = null) {
|
||||
function convertClaudeCommandToClineSkill(content, skillName, _runtime = null, cmdNames = null) {
|
||||
const { frontmatter, body } = extractFrontmatterAndBody(content);
|
||||
if (!frontmatter) return content;
|
||||
|
||||
|
||||
@@ -1659,7 +1659,7 @@ function cmdVerifySchemaDrift(
|
||||
const pDir = planningDir(cwd);
|
||||
const phasesDir = path.join(pDir, 'phases');
|
||||
if (!fs.existsSync(phasesDir)) {
|
||||
output({ drift_detected: false, blocking: false, message: 'No phases directory' }, raw);
|
||||
output({ block: false, drift_detected: false, blocking: false, message: 'No phases directory' }, raw);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -1679,7 +1679,7 @@ function cmdVerifySchemaDrift(
|
||||
|
||||
if (!phaseDir) {
|
||||
output(
|
||||
{ drift_detected: false, blocking: false, message: `Phase directory not found: ${phaseArg}` },
|
||||
{ block: false, drift_detected: false, blocking: false, message: `Phase directory not found: ${phaseArg}` },
|
||||
raw,
|
||||
);
|
||||
return;
|
||||
@@ -1709,15 +1709,21 @@ function cmdVerifySchemaDrift(
|
||||
|
||||
const result = checkSchemaDrift(allFiles, executionLog, { skipCheck: !!skipFlag }) as unknown as Record<string, unknown>;
|
||||
|
||||
const isSkipped = !!result['skipped'];
|
||||
output(
|
||||
{
|
||||
// Uniform gate contract: `block` = true means "this gate's bad condition is met".
|
||||
// When skipCheck is true (GSD_SKIP_SCHEMA_CHECK=true), the gate is bypassed —
|
||||
// block must be false regardless of whether drift was detected.
|
||||
// drift_detected and blocking are kept for compatibility.
|
||||
block: isSkipped ? false : !!result['driftDetected'],
|
||||
drift_detected: result['driftDetected'],
|
||||
blocking: result['blocking'],
|
||||
schema_files: result['schemaFiles'],
|
||||
orms: result['orms'],
|
||||
unpushed_orms: result['unpushedOrms'],
|
||||
message: result['message'],
|
||||
skipped: result['skipped'] || false,
|
||||
skipped: isSkipped,
|
||||
},
|
||||
raw,
|
||||
);
|
||||
@@ -1735,6 +1741,8 @@ function cmdVerifyCodebaseDrift(cwd: string, raw: boolean): void {
|
||||
const structurePath = path.join(codebaseDir, 'STRUCTURE.md');
|
||||
if (!fs.existsSync(structurePath)) {
|
||||
emit({
|
||||
// Uniform gate contract: block = action_required (false when skipped).
|
||||
block: false,
|
||||
skipped: true,
|
||||
reason: 'no-structure-md',
|
||||
action_required: false,
|
||||
@@ -1749,6 +1757,7 @@ function cmdVerifyCodebaseDrift(cwd: string, raw: boolean): void {
|
||||
structureMd = fs.readFileSync(structurePath, 'utf-8');
|
||||
} catch (err) {
|
||||
emit({
|
||||
block: false,
|
||||
skipped: true,
|
||||
reason: 'cannot-read-structure-md: ' + (err instanceof Error ? err.message : String(err)),
|
||||
action_required: false,
|
||||
@@ -1763,6 +1772,7 @@ function cmdVerifyCodebaseDrift(cwd: string, raw: boolean): void {
|
||||
const revProbe = execGit(['rev-parse', 'HEAD'], { cwd }) as unknown as { exitCode: number; stdout: string };
|
||||
if (revProbe.exitCode !== 0) {
|
||||
emit({
|
||||
block: false,
|
||||
skipped: true,
|
||||
reason: 'not-a-git-repo',
|
||||
action_required: false,
|
||||
@@ -1784,6 +1794,7 @@ function cmdVerifyCodebaseDrift(cwd: string, raw: boolean): void {
|
||||
const diff = execGit(['diff', '--name-status', base, 'HEAD'], { cwd }) as unknown as { exitCode: number; stdout: string };
|
||||
if (diff.exitCode !== 0) {
|
||||
emit({
|
||||
block: false,
|
||||
skipped: true,
|
||||
reason: 'git-diff-failed',
|
||||
action_required: false,
|
||||
@@ -1825,10 +1836,13 @@ function cmdVerifyCodebaseDrift(cwd: string, raw: boolean): void {
|
||||
runtime: resolveRuntime(cwd),
|
||||
});
|
||||
|
||||
const actionRequired = !!driftResult['actionRequired'];
|
||||
emit({
|
||||
// Uniform gate contract: block = action_required.
|
||||
block: actionRequired,
|
||||
skipped: !!driftResult['skipped'],
|
||||
reason: driftResult['reason'] || null,
|
||||
action_required: !!driftResult['actionRequired'],
|
||||
action_required: actionRequired,
|
||||
directive: driftResult['directive'],
|
||||
spawn_mapper: !!driftResult['spawnMapper'],
|
||||
affected_paths: driftResult['affectedPaths'] || [],
|
||||
@@ -1840,6 +1854,7 @@ function cmdVerifyCodebaseDrift(cwd: string, raw: boolean): void {
|
||||
});
|
||||
} catch (err) {
|
||||
emit({
|
||||
block: false,
|
||||
skipped: true,
|
||||
reason: 'exception: ' + (err && err instanceof Error ? err.message : String(err)),
|
||||
action_required: false,
|
||||
|
||||
Reference in New Issue
Block a user