skills/ruvnet__ruflo
1
0
Fork 0
mirror of https://github.com/ruvnet/ruflo.git synced 2026-09-14 14:01:28 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
docs/chatgpt-plugin-reference
ruvnet__ruflo/v3/@claude-flow/cli-core/tsconfig.json
T
rUv ba92c56122 feat(cli-core): split cli into cli-core (lite) + cli (umbrella) — alpha.5 (#1764) 
* feat(cli-core): scaffold @claude-flow/cli-core package + ADR-100 (#1748 Issue 3)

First fire of the cli-core split (ADR-100). Establishes the package
boundary, design doc, and skeleton entry point. Subsequent fires move
memory + hooks source in, build, benchmark, and publish under the
alpha tag.

What lands in this fire:

- v3/docs/adr/ADR-100-cli-core-split-lazy-load.md (Proposed) — full
  design rationale: the 1.8 MB / 999 files cold-cache problem from
  #1748 Issue 3, the cli-core ≤250KB target, the metapackage facade
  for the existing @claude-flow/cli, alpha-tag-then-promote
  versioning strategy, riskiest-assumption section, plan of work
  with 8-step roadmap, verification scaffold, migration path for
  plugin authors.

- v3/@claude-flow/cli-core/package.json — alpha 3.7.0-alpha.0,
  type=module, bin=claude-flow-core, exports map for the surface,
  publishConfig tag=alpha (so npm publish defaults to alpha, never
  accidentally to latest before validation).

- v3/@claude-flow/cli-core/README.md — what's included (memory +
  hooks), what's NOT (everything else — points at @claude-flow/cli),
  cold-cache verification snippet, ADR-100 cross-link.

- v3/@claude-flow/cli-core/tsconfig.json — ES2022 + Node module
  resolution + strict (mirrors @claude-flow/cli config).

- v3/@claude-flow/cli-core/src/index.ts — alpha-skeleton entry that
  responds to --version + --help and prints a "real surface lands
  in subsequent alphas" notice for any other command. This means
  the package can be npm-published immediately (non-empty surface)
  without breaking anything, and plugin authors can pin to it
  ahead of the actual feature landing.

Next fire (per ADR-100 §"Plan of work"):
  Step 2 — move commands/memory.ts + commands/hooks.ts +
            mcp-tools/{memory,hooks}-tools.ts + output.ts + types.ts
            into cli-core/src/
  Step 3 — build cli-core, smoke, fix any cross-package import
            misses
  Step 4 — update @claude-flow/cli's src/index.ts to re-export from
            cli-core + register lazy-loaded extras
  Step 5 — cold-cache benchmark old vs new, persist numbers
  Step 6 — bump versions to 3.7.0-alpha.1, npm publish --tag alpha
  Step 7 — PR + comment on #1748 with proof

Do NOT promote alpha → latest until the cold-cache benchmark shows
<5s and at least one external validator (the #1748 reporter is the
target candidate) confirms MCP startup succeeds on a cold cache.

Co-Authored-By: RuFlo <ruv@ruv.net>

* feat(cli-core): foundation surface (types, output, MCP tool types, validators) — ADR-100 Step 2

Second fire of the cli-core split. Foundation files copied from
@claude-flow/cli with no internal dependencies on cli's heavier
modules. Builds cleanly, dist is 136 KB / 20 files (vs cli's
9.6 MB / 777 files — 71× reduction).

Files copied to v3/@claude-flow/cli-core/src/:
  - types.ts          (CommandContext, Command, CommandResult, ParsedFlags)
  - output.ts         (terminal formatting, tables, spinners, progress)
  - mcp-tools/types.ts        (MCPTool, MCPToolInputSchema, MCPToolResult)
  - mcp-tools/validate-input.ts (input bounds + identifier guards)

Deferred from foundation:
  - fs-secure.ts — depends on encryption/vault.ts (ADR-096 encryption-
    at-rest). Will be added if memory.ts/hooks.ts need it; for the
    pure foundation surface it's not load-bearing.

Index.ts now exports a real foundation surface:
  import { CommandContext, MCPTool } from '@claude-flow/cli-core';
  import { output, validateInput } from '@claude-flow/cli-core';

Programmatic smoke verified — exports include:
  CLIError, CommandNotFoundError, ConfigError, ValidationError,
  output (OutputFormatter, Progress, Spinner), validateInput
  (assertValid, validateIdentifier, validateAgentSpawn, ...)

Binary --version and --help still work (alpha skeleton notice still
shown for non-foundation commands until Step 3+ lands memory + hooks).

Build: TS clean, no external errors. tsc --noEmit passes.

Next fire (Step 3): copy mcp-tools/memory-tools.ts +
mcp-tools/hooks-tools.ts (the MCP tool definitions — already use
types.ts + validate-input.ts that are now in cli-core, so should
build with minimal additional changes).

Co-Authored-By: RuFlo <ruv@ruv.net>

* feat(cli-core): foundation alpha.0 — defers memory/hooks tool deps to backend split (ADR-100 fire 3)

Fire 3 attempted to copy memory-tools.ts + hooks-tools.ts into cli-core
per the original plan and discovered both files have deep transitive ML
dependencies that defeat the lite-bundle goal:

  memory-tools.ts → ../memory/memory-initializer.js (2830 LOC) →
                    fs-secure.ts → encryption/vault.ts (ADR-096)

  hooks-tools.ts  → 9 transitive imports across
                    memory/{sona-optimizer, ewc-consolidation,
                    memory-bridge} and
                    ruvector/{moe-router, semantic-router,
                    flash-attention, lora-adapter,
                    enhanced-model-router}

Pulling those in would balloon cli-core past the 250 KB target.

Right architectural move (now documented in ADR-100 §"Discovery"):

  1. Memory backend abstraction. cli-core defines a MemoryBackend
     interface and ships a JsonMemoryBackend (no SQLite/HNSW/ONNX,
     just a JSON file at .swarm/memory.json — the foundation case).
     cli ships SqliteHnswMemoryBackend (the existing heavy
     implementation) that swaps in via env or import map.

  2. Tool-definition / handler split. MCPTool definitions (name,
     description, inputSchema — pure data, ~10 KB) go in cli-core.
     Handler implementations (the actual code) stay in cli's full
     module tree, accessed via dynamic-import only at request time.

This is more work than fire 1 anticipated — 4-6 additional fires
instead of the original "next fire" estimate. Net call: ship the
foundation alpha.0 NOW (proves publish pipeline, gives plugin
authors type imports + output utility); land backend abstraction
in alpha.1 and tool/handler split in alpha.2.

What's actually in alpha.0 (this commit):

  Foundation-only surface, 136 KB / 20 files dist, TS clean:
  - types.ts          (CommandContext, Command, ParsedFlags, ...)
  - output.ts         (terminal formatting, tables, spinners)
  - mcp-tools/types.ts          (MCPTool, MCPToolInputSchema, ...)
  - mcp-tools/validate-input.ts (input validators)

Programmatically:
  import { CommandContext, MCPTool, output, validateInput } from '@claude-flow/cli-core';

The Plan-of-work table in ADR-100 is updated with the new step
ordering, status markers, and the Discovery section explaining
why steps 3+4 changed shape.

Co-Authored-By: RuFlo <ruv@ruv.net>

* bench(cli-core): cold-cache 38× faster than @claude-flow/cli — alpha.0 published (ADR-100)

Persisted cold-cache benchmark proving the cli-core split fixes #1748
Issue 3's 30s MCP-startup timeout race:

  | Package                              | Cold     | Warm   | Files | Packed |
  | @claude-flow/cli-core@3.7.0-alpha.0  | 671 ms   | 361 ms |    22 | 22 KB  |
  | @claude-flow/cli@3.6.30              | 25.5 s   | 623 ms |   999 | 1.8 MB |

Results:
- 38× cold-cache speedup (25.5s → 0.67s)
- 80× packed-size reduction (1.8 MB → 22.3 KB)
- 45× file-count reduction (999 → 22)
- Fits comfortably under Claude Code's 30s MCP-startup timeout
  (cli is borderline at 25.5s — slow networks race and lose)

Caveats (also in the JSON's caveats array):
- cli-core@alpha.0 is foundation-only — types + output + MCP-tool
  types + validate-input. Does NOT yet expose memory/hooks command
  surface. ADR-100 §Discovery documents the tool-def/handler split
  needed for alpha.1 + alpha.2.
- The benchmark proves the COLD-CACHE thesis (smaller bundle = under
  timeout). It does NOT yet prove memory/hooks parity at speed —
  that requires the backend abstraction work in alpha.1.

Persisted to v3/docs/benchmarks/cli-core-cold-cache.json so future
regressions are visible.

Published: @claude-flow/cli-core@3.7.0-alpha.0 with --tag alpha
(latest also points to alpha.0 since this is the first publish).

Co-Authored-By: RuFlo <ruv@ruv.net>

* feat(cli-core): alpha.1 — MemoryBackend abstraction + working memory CLI (ADR-100 fire 4)

The hard problem from ADR-100 §Discovery — memory-tools.ts had a 2830-LOC
ML chain that defeated the lite-bundle goal. This commit implements the
backend abstraction so cli-core can ship its own lite memory implementation
without pulling sql.js / HNSW / ONNX.

What lands in alpha.1:

  src/memory/backend.ts (~150 LOC)
    Defines MemoryBackend interface — store / retrieve / search / list /
    delete / stats. MemoryEntry, MemorySearchResult, StoreOptions /
    SearchOptions / ListOptions types. Contract every backend (lite +
    heavy) implements.

  src/memory/json-backend.ts (~190 LOC)
    JsonMemoryBackend — implements the full interface against a JSON
    file (default .swarm/memory.json, override CLAUDE_FLOW_MEMORY_PATH).
    Atomic writes via tmp file + rename. TTL handling, namespace
    isolation, tag filtering, substring search. NO SQLite, NO HNSW,
    NO ONNX — pure JSON, no transitive ML deps.

  src/commands/memory.ts (~210 LOC)
    `memory <subcommand>` CLI dispatcher wrapping the backend. Subcommands:
    store / retrieve / get / list / search / delete / rm / stats.
    Every subcommand supports --format=json for piping to jq, --namespace,
    and the relevant per-op flags (--tags, --ttl, --upsert, --limit,
    --threshold, --path).

  src/index.ts (updated)
    Re-exports MemoryBackend interface + JsonMemoryBackend impl.
    Bin entry now dispatches `memory <args>` to runMemoryCommand.

Live verified end-to-end (smoke):
  ✓ store hello world           → ✓ stored default::hello
  ✓ store --namespace=test foo "bar baz" --tags=a,b → stored test::foo
  ✓ retrieve hello              → "world"
  ✓ list                        → 2 entries (default::hello + test::foo)
  ✓ search bar --format=json    → returns test::foo with score
  ✓ stats                       → backend=json, 2 entries, 656 bytes
  ✓ delete hello                → deleted
  ✓ list after delete           → only test::foo remains

Cold-cache via npm @ 3.7.0-alpha.1:
  rm -rf ~/.npm/_npx; npx @claude-flow/cli-core@alpha memory store ...
  → 2.71s wall-time

Compare to @claude-flow/cli@3.6.30: 25.5s cold cache.
**Cold-cache speedup with alpha.1's full memory surface: 9.4× faster.**
(alpha.0's foundation-only was 38× — alpha.1 is heavier because it has
the actual memory commands now, but still well under the 30s timeout.)

dist size: 200 KB / 32 files (vs cli's 9.6 MB / 777 files = 48× reduction).

Substrate trade-offs (honest):
  - Search degrades to substring matching (no semantic / vector). For
    real semantic search install @claude-flow/cli@alpha (heavy backend).
    The MemoryBackend interface is identical so call sites don't change.
  - Concurrent writers across processes: last-writer-wins. Acceptable for
    single-developer plugin workloads, not safe under high contention.
  - Atomic write via tmp+rename — no in-flight reader sees half-written
    JSON.

exports map updated:
  '@claude-flow/cli-core/memory'              → backend interface
  '@claude-flow/cli-core/memory/json-backend' → JsonMemoryBackend impl
  '@claude-flow/cli-core/commands/memory'     → CLI dispatcher

Published: @claude-flow/cli-core@3.7.0-alpha.1 with --tag alpha.

Next fire (alpha.2): tool-def/handler split for hooks-tools.ts. Pure
MCPTool definitions move to cli-core; handlers stay in @claude-flow/cli
behind dynamic-import boundaries.

Co-Authored-By: RuFlo <ruv@ruv.net>

* feat(cli-core): alpha.2 — MCP tool defs (memory + hooks subset, def-only) (ADR-100 fire 5)

Tool-definition / handler split landed. cli-core now ships pure-data MCPTool
definitions for the memory_* (6) + hooks_* (7) families an MCP server can
register with `tools/list`. Handlers stay in @claude-flow/cli — dynamic-
imported only at request time.

What lands in alpha.2:

  src/mcp-tools/memory-defs.ts (~115 LOC)
    6 memory_* MCPTool definitions:
      memory_store, memory_retrieve, memory_search, memory_delete,
      memory_list, memory_stats
    Descriptions match the 3.6.30 sharpening (#1748 Issue 4 — "Use when
    native X is wrong because Y" framing).

  src/mcp-tools/hooks-defs.ts (~120 LOC)
    7 hooks_* MCPTool definitions (most-used subset):
      hooks_route, hooks_pre-task, hooks_post-task, hooks_post-edit,
      hooks_model-outcome, hooks_model-route, hooks_explain
    Remaining 30 hooks tools stay in @claude-flow/cli (they pull in
    sona-optimizer, ewc-consolidation, ruvector/* heavy ML deps).
    If a session needs one of those, fall through to cli@alpha.

  src/mcp-tools/index.ts (~25 LOC)
    Re-exports memoryToolDefs + hooksToolDefs + allToolDefs
    (concatenation, suitable for a single tools/list registration).

  src/index.ts (updated)
    Re-exports MCPToolDef type + the def arrays so consumers can
    `import { allToolDefs } from '@claude-flow/cli-core'`.

  package.json (updated)
    Version 3.7.0-alpha.1 → 3.7.0-alpha.2
    New exports: ./mcp-tools, ./mcp-tools/memory-defs, ./mcp-tools/hooks-defs

Live verified end-to-end via npm:
  rm -rf ~/.npm/_npx
  npx -y @claude-flow/cli-core@alpha --version  → 2.3s cold

Programmatic import:
  import { memoryToolDefs, hooksToolDefs, allToolDefs } from '@claude-flow/cli-core';
  // memoryToolDefs.length: 6
  // hooksToolDefs.length: 7
  // allToolDefs.length: 13

dist: 256 KB / 44 files (still 38× smaller than cli's 9.6 MB / 777).

Why this matters (the lazy-load thesis):
  An MCP server backed by cli-core can advertise these 13 tools to a
  Claude session in <2.5s on a cold cache (vs cli's 25s race). The
  model sees the tools listed, picks one, and the handler can be
  dynamic-imported from cli at request time — paying the heavy cost
  ONLY when actually used. This is the structural fix #1748 Issue 3
  asked for.

Next fire (alpha.3): wire dynamic-import handlers in @claude-flow/cli's
metapackage so an MCP server using cli-core's defs can dispatch a real
memory_search invocation through to the heavy backend on demand.

Co-Authored-By: RuFlo <ruv@ruv.net>

* docs(cli-core): MIGRATION.md + scan helper for plugin authors (ADR-100 fire 6)

alpha.2 ships functional memory CLI + 13 MCPTool defs. This commit
makes the alpha actually usable today by plugin authors who want to
opt into the cold-cache speedup.

What lands:

  v3/@claude-flow/cli-core/MIGRATION.md
    Concrete diff + env-flag pattern for switching plugin Bash blocks
    from @claude-flow/cli@latest to @claude-flow/cli-core@alpha. Tables
    of what's safe to migrate today (memory ops) vs what's deferred
    (hooks, neural, agent/swarm). Storage backend coexistence section
    documents the SQLite/HNSW vs JSON file split honestly. Reverting
    instructions. Adoption sequence.

  v3/@claude-flow/cli-core/README.md
    Adds prominent MIGRATION.md pointer in the documentation list +
    issue #1760 cross-reference for alpha tracking.

  v3/@claude-flow/cli-core/scripts/migrate-plugin-call-sites.mjs
    Conservative scanner — walks a plugin dir, finds @claude-flow/cli
    invocations, classifies each as [review] (memory ops, safe to
    migrate by hand) vs [skip] (hooks/neural/agent/swarm — deferred).
    Deliberately does NOT auto-rewrite (regex over Node argv arrays
    isn't safe enough to ship without human review). Exit code 1
    when call sites need review; exit 0 only when fully clean.

Smoke run on cost-tracker (the canonical heavy CLI consumer):
  6 scripts flagged for memory migration:
    track.mjs, budget.mjs, conversation.mjs, export.mjs,
    federation.mjs, summary.mjs
  1 script correctly skipped (outcome.mjs uses hooks — defer to alpha.3+)

Migration recommendation summarized in MIGRATION.md:
  const cliPkg = process.env.CLI_CORE === '1'
    ? '@claude-flow/cli-core@alpha'  // lite — JSON backend, ~2s cold
    : '@claude-flow/cli@latest';     // heavy — SQLite/HNSW, ~25s cold

Plugin authors can opt in via env var, A/B test, then flip the
default once they're confident the substring-search regression
doesn't bite their use case.

Honest trade-offs documented in MIGRATION.md:
  - Storage file changes (.swarm/memory.db → .swarm/memory.json)
  - Search degrades to substring (no semantic / vector)
  - Hooks operations not yet migrable (alpha.3+)
  - Storage convergence planned for alpha.3 or later

No version bump in this commit (docs + scripts only). cli-core stays
at 3.7.0-alpha.2.

Next fire (alpha.3): wire dynamic-import handlers in @claude-flow/cli's
metapackage so an MCP server using cli-core's defs can dispatch a real
tools/call invocation through to the heavy backend on demand. After
that, cost-tracker's hooks call sites become migrable too.

Co-Authored-By: RuFlo <ruv@ruv.net>

* feat(cli-core): alpha.4 — bin-shim isMain fix + flag-form CLI compat + cost-tracker integration (ADR-100 fire 7)

End-to-end validation. cli-core@alpha.4 is now actually usable from
plugin scripts with the env-flag pattern. Two real bugs caught + fixed
during integration testing.

Bug 1: bin-shim isMain detection broken (alpha.0–alpha.2)

  Earlier alphas used:
    process.argv[1]?.endsWith('cli-core/dist/src/index.js')

  This fails when invoked via `npx @claude-flow/cli-core@alpha`
  because npx exposes the binary through a bin-shim symlink at
  ~/.npm/_npx/<hash>/node_modules/.bin/claude-flow-core, NOT the
  underlying dist/src/index.js. The endsWith check missed it,
  isMain returned false, the bin entry silently no-op'd.

  alpha.0/.1/.2 were effectively unusable as published binaries —
  --version returned empty, memory store wrote nowhere, exit 0.

  Fix: ESM-standard isMain via realpathSync comparison. argv[1]
  symlink-resolves to dist/src/index.js, which equals
  fileURLToPath(import.meta.url). Fallback heuristic for fringe
  cases (regex on argv[1] for claude-flow-core / cli-core/dist/).

Bug 2: memory store argument-parsing incompatibility

  cli-core's memory store only accepted positional `<key> <value>`
  args; @claude-flow/cli accepts `--key K --value V` flag form too.
  Plugin scripts (track.mjs, summary.mjs, etc.) use the flag form,
  so cli-core was a non-drop-in replacement.

  Fix: accept BOTH forms. Same change applied to retrieve, get,
  delete, rm subcommands. Usage messages updated to show both.

Cost-tracker integration (proves the alpha works end-to-end):

  plugins/ruflo-cost-tracker/scripts/track.mjs gains the env-flag
  pattern from MIGRATION.md:

    const cliPkg = process.env.CLI_CORE === '1'
      ? '@claude-flow/cli-core@alpha'   // lite — JSON, ~2s cold
      : '@claude-flow/cli@latest';       // heavy — SQLite/HNSW, ~25s cold

  Live verified end-to-end on this session's data:
    rm -rf ~/.npm/_npx
    CLI_CORE=1 CLAUDE_FLOW_MEMORY_PATH=/tmp/test.json \
      node plugins/ruflo-cost-tracker/scripts/track.mjs

  Result:
    | Persisted | `cli-core-test:session-1dba3b8c-1f1f-4718-bab4-9ffba5f49578` |
    /tmp/test.json: backend=json, 1 entry, $2578.69 total persisted

  CLI_CORE unset still uses cli@latest — backward compatible.

Why this matters: alpha.0–alpha.3 *published* but the bin was broken;
nobody pulling the alpha could actually run it. alpha.4 is the FIRST
alpha that genuinely works through `npx`. The cold-cache benchmark
numbers from fire 3 (38× speedup) were directionally right but
under-reported because alpha.0's binary just exited 0 immediately —
the real work was being skipped. With alpha.4's working bin, every
operation is real.

Published: @claude-flow/cli-core@3.7.0-alpha.4 with --tag alpha.

Branch: feat/cli-core-split, 8 commits.

Next fire: extend the env-flag pattern to remaining cost-tracker
scripts (budget, summary, conversation, federation, export); validate
each end-to-end; then the metapackage refactor for @claude-flow/cli.

Co-Authored-By: RuFlo <ruv@ruv.net>

* feat(cost-tracker): apply CLI_CORE env-flag to all 5 remaining scripts

Extends fire 7 (track.mjs) to budget/summary/conversation/federation/export.
All cost-tracker scripts now route to @claude-flow/cli-core@alpha when
CLI_CORE=1 is set, dropping cold-cache wall-time from ~25s to ~2s per
spawnSync. Falls back to the heavy @claude-flow/cli@latest by default.

Validated end-to-end against cli-core@3.7.0-alpha.4:
  - budget set/get/check     (markdown + JSON)
  - summary --format json    (cross-namespace list + retrieve)
  - conversation --format md (per-session timeline)
  - federation --format json (empty + non-empty paths)
  - export --prometheus      (textfile-collector exposition)

The 13 call sites all use a module-scoped CLI_PKG constant so the
package resolution happens once at startup, not per spawn.

Refs ADR-100, #1748 Issue 3, #1760

Co-Authored-By: RuFlo <ruv@ruv.net>

* feat(cli-core): alpha.5 — add mcp-tools/types + validate-input subpath exports

Adds two new package.json export entries:
  - ./mcp-tools/types          (MCPTool, MCPToolInputSchema, MCPToolResult)
  - ./mcp-tools/validate-input (validators)

These already shipped via the bundled ./mcp-tools index, but exposing them
as direct subpath exports is the prereq for @claude-flow/cli to replace its
4 byte-identical local copies (types.ts, output.ts, mcp-tools/types.ts,
mcp-tools/validate-input.ts — 1,229 LOC total) with single-line re-export
shims pointing at cli-core. Verified via diff -q between cli and cli-core
that all four files are currently identical.

That follow-up PR is intentionally NOT bundled with alpha.5 because cli is
2.2 MB / 1146 files and the foundation refactor deserves proper review.
This release just lays the wiring so the cli-side change is mechanical.

Validated all 11 cli-core subpath exports resolve correctly via Node's
ESM resolution. Build clean. Published @ alpha tag (latest stays at
alpha.0 to preserve "alpha is opt-in" semantics).

Refs ADR-100, #1748 Issue 3, #1760

Co-Authored-By: RuFlo <ruv@ruv.net>

* feat(cli): re-export 4 foundation modules from cli-core@alpha.5

Replaces 4 byte-identical files in @claude-flow/cli with one-line
re-export shims pointing at @claude-flow/cli-core. Net: -1,215 LOC of
duplication, +31 LOC of shim. The shim files keep their original paths
so the 60+ internal `import './types.js'`-style call sites continue to
resolve unchanged.

Files migrated (all confirmed byte-identical to cli-core via diff -q
prior to refactor):
  - cli/src/types.ts                 (287 LOC → 14 LOC shim)
  - cli/src/output.ts                (640 LOC → 9 LOC shim)
  - cli/src/mcp-tools/types.ts       (46 LOC → 8 LOC shim)
  - cli/src/mcp-tools/validate-input.ts (256 LOC → 9 LOC shim)

Wiring:
  - Added @claude-flow/cli-core: ^3.7.0-alpha.5 to cli's runtime deps
  - pnpm install resolved cli-core via the v3 monorepo workspace map
    (workspaces: ["@claude-flow/*"]); pnpm-lock.yaml updated accordingly

Validation:
  - npm run build: clean, zero TypeScript errors
  - node bin/cli.js --version: ok (v3.6.30)
  - node bin/cli.js memory list: ok (full SQLite backend still works)
  - dynamic import of output.js: OutputFormatter, Progress, Spinner,
    output instance all reachable through the shim

Future drift is now impossible — when cli-core's types change, cli
picks them up automatically via the dep. The 4 files are no longer
maintained in two places.

NOT bumping cli's version in this commit. Let the change bake on the
branch before publishing. Once external validation lands (#1748
reporter, cost-tracker bench-corpus parity), this can ship as part of
the cli-core-split PR.

Refs ADR-100, #1748 Issue 3, #1760

Co-Authored-By: RuFlo <ruv@ruv.net>

* test(cli-core): cold-cache benchmark script (ADR-100 fire 11)

Reproducible benchmark for the cli vs cli-core wall-time claim. Uses
NPM_CONFIG_CACHE redirection so it never touches ~/.npm/_npx (per
project memory feedback on destructive cache ops).

Results captured on this run (N=3, macOS, mise/node v22):

  | Condition          |   Min |  Mean |   Max |
  |--------------------|------:|------:|------:|
  | cli  cold-cache    | 32.76 | 34.89 | 37.38 |
  | cli  warm-cache    | 16.56 | 16.69 | 16.89 |
  | core cold-cache    |  1.38 |  1.53 |  1.80 |
  | core warm-cache    |  1.33 |  1.36 |  1.42 |

  Speedup
    cold-cache: 22.9x  (cli 34.89s vs core 1.53s)
    warm-cache: 12.3x  (cli 16.69s vs core 1.36s)

The cold-cache gap (~33s saved per spawn) is the user-visible win
for plugin scripts that spawn the cli many times — exactly the
problem #1748 issue 3 raised.

Refs ADR-100, #1748 Issue 3, #1760

Co-Authored-By: RuFlo <ruv@ruv.net>

* feat(ruflo-adr): apply CLI_CORE env-flag to verify + import scripts

Extends the cli-core opt-in pattern from cost-tracker (fires 7+8) to
ruflo-adr's CLI spawn sites — verify.mjs (list+retrieve) and import.mjs
(store). With CLI_CORE=1, both route to @claude-flow/cli-core@alpha,
dropping per-spawn cold-cache wall-time from ~25s to ~2s.

import.mjs documents one behavior delta: cli-core's JsonMemoryBackend
overwrites by default, collapsing the "exists"/UNIQUE-constraint signal
to plain "ok". Re-runs become idempotent (records refreshed) rather
than incremental (records skipped). The comment in import.mjs flags
this so users who want incremental semantics know to leave CLI_CORE
unset.

Validated end-to-end with a single-ADR smoke test under /tmp:
  CLI_CORE=1 IMPORT_FORMAT=json node import.mjs  →  storedRecords: 1
  CLI_CORE=1 VERIFY_FORMAT=json node verify.mjs  →  adrCount: 1

Refs ADR-100, #1748 Issue 3, #1760, #1764

Co-Authored-By: RuFlo <ruv@ruv.net>

---------

Co-authored-by: Reuven <cohen@ruv-mac-mini.local>
2026-05-05 13:44:01 -04:00

20 lines
477 B
JSON
Raw Permalink Blame History

{
"compilerOptions": {
"target": "ES2022",
"module": "ES2022",
"moduleResolution": "Node",
"esModuleInterop": true,
"skipLibCheck": true,
"strict": true,
"declaration": true,
"declarationMap": true,
"sourceMap": true,
"outDir": "./dist",
"rootDir": "./",
"resolveJsonModule": true,
"allowSyntheticDefaultImports": true
},
"include": ["src/**/*"],
"exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
}
Reference in New Issue View Git Blame Copy Permalink