peaks-loop 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/src/services/fixture/fixture-sanitize-service.js

@@ -1,161 +0,0 @@
-/**
- * v2.14.0 G1 AC-1.5 — Fixture sanitization service.
- *
- * Five sanitize rules (PRD AC-1.5 + the explicit
- * "username path segment" extension):
- *
- *   1. cookie-redaction              — `Cookie: <name>=<value>` / `Set-Cookie: ...`
- *   2. token-redaction               — Bearer tokens, JWTs, API keys (sk-/ghp-/... prefixes)
- *   3. sso-url-redaction             — SSO redirect URLs with embedded tokens (`?token=`,
- *                                       `?code=`, `#access_token=`)
- *   4. personal-email-redaction      — RFC-5322-shaped personal emails
- *   5. username-path-segment-redaction — `/Users/<name>/` and `C:\\Users\\<name>\\`
- *                                       path segments (only the username segment,
- *                                       not the whole path)
- *
- * Sanitize contract:
- *   - Pure (no IO). `sanitizeFixture(input: string)` returns the redacted
- *     string + a `SanitizationReport`.
- *   - `passed: true` only when ALL rules have been applied. The capture
- *     CLI refuses to write a fixture with `passed: false`.
- *   - Each rule produces a stable replacement token (`<REDACTED-<rule}>`)
- *     so the test suite can grep for redaction without depending on
- *     the original (potentially sensitive) values.
- *
- * Why a separate service (not inline in capture CLI):
- *   - Unit-testable in isolation. The PRD AC-1.5 mandate is "tested",
- *     and 5 sanitize rules need 5+ test cases per rule. Keeping the
- *     logic in a service makes the tests trivial.
- *   - Re-usable by future capture tools (`peaks fixture redact`,
- *     `peaks fixture snapshot-share`) without forking logic.
- */
-import { z } from 'zod';
-export const SANITIZE_RULE_NAMES = [
-    'cookie-redaction',
-    'token-redaction',
-    'sso-url-redaction',
-    'personal-email-redaction',
-    'username-path-segment-redaction'
-];
-export const SANITIZE_RULES = [
-    {
-        name: 'cookie-redaction',
-        // Match `Cookie: name=value` and `Set-Cookie: name=value; ...` headers.
-        // Also match bare `name=value` cookie fragments inside JSON for fixtures
-        // that originated from a JSON debug capture.
-        pattern: /(?:set-cookie|cookie)\s*:\s*([^;\r\n]+)/gi,
-        replacement: '<REDACTED-cookie>'
-    },
-    {
-        name: 'token-redaction',
-        // Bearer tokens (Authorization: Bearer ...), JWTs (xxx.yyy.zzz),
-        // and well-known API-key prefixes.
-        pattern: /(?:bearer\s+)[a-zA-Z0-9._\-+/=]{12,}|eyJ[a-zA-Z0-9._\-+/=]{20,}|(?:sk-|ghp_|gho_|ghs_|ghu_|ghr_|github_pat_|xox[abprs]-|AIza[0-9A-Za-z_\-]{35})[A-Za-z0-9_\-]+/gi,
-        replacement: '<REDACTED-token>'
-    },
-    {
-        name: 'sso-url-redaction',
-        // SSO callback URLs with embedded tokens via `?` (e.g. `?token=`,
-        // `?code=`, `?access_token=`) or via fragment `#access_token=`.
-        pattern: /\bhttps?:\/\/[^\s"'<>]*(?:[?&](?:token|code|access_token|id_token|assertion)=[^&\s"'<>]*|#[^/\s"'<>]*access_token=[^\s"'<>]*)/gi,
-        replacement: '<REDACTED-sso-url>'
-    },
-    {
-        name: 'personal-email-redaction',
-        // RFC-5322-ish local-part @ domain.tld. Restrict TLD to letters
-        // (length 2-24) to avoid false positives like `pr-1234` (no `@`).
-        pattern: /\b[A-Za-z0-9._%+\-]{1,64}@[A-Za-z0-9.\-]{1,255}\.[A-Za-z]{2,24}\b/g,
-        replacement: '<REDACTED-email>'
-    },
-    {
-        name: 'username-path-segment-redaction',
-        // `/Users/<name>/` on POSIX and `C:\\Users\\<name>\\` / `\\Users\\<name>\\`
-        // on Windows. The replacement PRESERVES the path separator that
-        // precedes the username (slash or backslash) so the rest of the
-        // path stays intact and the fixture still parses structurally.
-        pattern: /((?:\/Users\/|\/home\/|C:\\Users\\|\\\\Users\\|\\Users\\|\\home\\))[A-Za-z0-9._\-]+/g,
-        replacement: '$1<REDACTED-user>'
-    }
-];
-// ─── Zod schemas ──────────────────────────────────────────────────────
-export const SanitizationIssueSchema = z.object({
-    rule: z.string(),
-    match: z.string(),
-    position: z.number().int().nonnegative()
-});
-export const SanitizationReportSchema = z.object({
-    passed: z.boolean(),
-    rulesApplied: z.array(z.enum([
-        'cookie-redaction',
-        'token-redaction',
-        'sso-url-redaction',
-        'personal-email-redaction',
-        'username-path-segment-redaction'
-    ])),
-    issues: z.array(SanitizationIssueSchema)
-});
-// ─── Public API ───────────────────────────────────────────────────────
-/**
- * Apply all sanitize rules in order. Returns the redacted string and
- * a structured report. `passed` is `true` iff every rule from
- * `SANITIZE_RULE_NAMES` was applied (which it always is — the boolean
- * exists so future rules can short-circuit, and to give the CLI a
- * consistent contract surface).
- *
- * Pure function: no IO, no side effects. Safe to call in a tight loop.
- */
-export function sanitizeFixture(input) {
-    let redacted = input;
-    const issues = [];
-    const rulesApplied = [];
-    for (const rule of SANITIZE_RULES) {
-        rulesApplied.push(rule.name);
-        // Reset the regex (since they are global + stateful across calls
-        // when reused without resetting lastIndex).
-        rule.pattern.lastIndex = 0;
-        const matches = redacted.matchAll(rule.pattern);
-        let localCount = 0;
-        for (const m of matches) {
-            // Only record the redacted form (not the original sensitive value)
-            // to avoid leaking the secret back into the report.
-            issues.push({
-                rule: rule.name,
-                match: rule.replacement,
-                position: typeof m.index === 'number' ? m.index : 0
-            });
-            localCount++;
-        }
-        if (localCount > 0) {
-            redacted = redacted.replace(rule.pattern, rule.replacement);
-        }
-    }
-    return {
-        redacted,
-        report: {
-            passed: true,
-            rulesApplied,
-            issues
-        }
-    };
-}
-/**
- * Sanitize + structural sanity check. Refuses to produce a `passed:
- * true` report if the redacted output is empty, has zero newlines, or
- * is identical to the input AND the input contains any of the
- * forbidden patterns. This guards against accidental no-op sanitization.
- */
-export function sanitizeFixtureStrict(input) {
-    const result = sanitizeFixture(input);
-    const looksSanitized = result.redacted !== input ||
-        !SANITIZE_RULES.some((r) => {
-            r.pattern.lastIndex = 0;
-            return r.pattern.test(input);
-        });
-    if (input.length === 0 || result.redacted.length === 0 || !looksSanitized) {
-        return {
-            redacted: result.redacted,
-            report: { ...result.report, passed: false }
-        };
-    }
-    return result;
-}

package/dist/src/services/fixture/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * v2.14.0 G1 — Fixture services barrel.
- *
- * Re-exports both the sanitize + capture services so consumers (CLI,
- * tests) import from one path.
- */
-export { sanitizeFixture, sanitizeFixtureStrict, SANITIZE_RULES, SANITIZE_RULE_NAMES, SanitizationReportSchema, SanitizationIssueSchema, type SanitizeRule, type SanitizeRuleName, type SanitizationReport, type SanitizationIssue } from './fixture-sanitize-service.js';
-export { captureHistoricalFixture, captureDerivedVariant, ENVELOPE_KINDS, ENVELOPE_ON_DISK_PATH, ENVELOPE_FILE_EXTENSION, EDGE_CASE_VARIANTS, type EnvelopeKind, type EdgeCaseVariant, type HistoricalCaptureInput, type DerivedVariantInput, type CaptureInput, type CapturedFixture, type FixtureMeta } from './fixture-capture-service.js';

package/dist/src/services/fixture/index.js

@@ -1,8 +0,0 @@
-/**
- * v2.14.0 G1 — Fixture services barrel.
- *
- * Re-exports both the sanitize + capture services so consumers (CLI,
- * tests) import from one path.
- */
-export { sanitizeFixture, sanitizeFixtureStrict, SANITIZE_RULES, SANITIZE_RULE_NAMES, SanitizationReportSchema, SanitizationIssueSchema } from './fixture-sanitize-service.js';
-export { captureHistoricalFixture, captureDerivedVariant, ENVELOPE_KINDS, ENVELOPE_ON_DISK_PATH, ENVELOPE_FILE_EXTENSION, EDGE_CASE_VARIANTS } from './fixture-capture-service.js';

package/dist/src/services/fork/fork-sync-state.d.ts

@@ -1,85 +0,0 @@
-/**
- * v2.15.0 follow-up — G11: fork sync state service.
- *
- * Tracks the local fork's relationship to its upstream: which tag the
- * fork is based on, how many commits / files it has diverged, and a
- * history of past syncs. Persistence: `.peaks/fork-state.json` in the
- * project root.
- *
- * Pure functions on top of a typed state object. The CLI surfaces 5
- * commands (status / upstream-check / sync-plan / sync / sync-verify)
- * but the actual upstream fetch + merge is deferred to a follow-up
- * slice; this slice ships the model + the dry-run / plan / record path.
- */
-export interface ForkBaseline {
-    /** Upstream repo identifier (e.g. "github.com/xxx/hermes"). */
-    readonly upstream: string;
-    /** Tag or commit the fork is currently based on. */
-    readonly basedOn: string;
-    /** ISO timestamp when the baseline was recorded. */
-    readonly recordedAt: string;
-    /** Number of commits the local fork is ahead of the baseline. */
-    readonly commitsAhead: number;
-    /** Number of files the local fork has changed vs the baseline. */
-    readonly filesChanged: number;
-}
-export interface ForkSyncRecord {
-    /** Sync plan id (e.g. "sync-2026-06-28-v1.20.0"). */
-    readonly syncId: string;
-    /** Target upstream tag. */
-    readonly targetTag: string;
-    /** ISO timestamp when the sync plan was created. */
-    readonly plannedAt: string;
-    /** Predicted conflict points (file globs / paths). */
-    readonly predictedConflicts: readonly string[];
-    /** Business patches that need to be replayed after the sync. */
-    readonly businessPatches: readonly string[];
-    /** Sync status. */
-    readonly status: 'planned' | 'in-progress' | 'verified' | 'failed';
-    /** Optional verification notes. */
-    readonly verificationNotes?: string;
-}
-export interface ForkState {
-    /** Schema version (currently 1). */
-    readonly version: 1;
-    /** Current baseline (null when the project is not a fork). */
-    readonly baseline: ForkBaseline | null;
-    /** History of sync plans + results. */
-    readonly history: readonly ForkSyncRecord[];
-}
-export declare const EMPTY_FORK_STATE: ForkState;
-export declare function getForkStatePath(projectRoot: string): string;
-export declare function readForkState(projectRoot: string): ForkState;
-export declare function writeForkState(projectRoot: string, state: ForkState): void;
-/**
- * Record a new sync plan. The state is immutable; the returned state
- * has the new plan appended to `history`.
- */
-export declare function appendSyncRecord(state: ForkState, record: ForkSyncRecord): ForkState;
-/**
- * Update an existing sync record's status (e.g. planned → verified).
- * Returns the state unchanged when the record is not found.
- */
-export declare function updateSyncRecordStatus(state: ForkState, syncId: string, status: ForkSyncRecord['status'], notes?: string): ForkState;
-/**
- * Generate a sync plan id from a target tag. Format:
- * `sync-<ISO-date>-<tag-sanitized>`.
- */
-export declare function makeSyncId(targetTag: string, now?: Date): string;
-/**
- * Recommend stable tags to sync to, given a list of available tags.
- * "Stable" = no pre-release suffix (no `-alpha`, `-beta`, `-rc`).
- * Picks the latest stable tag that is NEWER than the current baseline.
- */
-export declare function recommendStableTags(availableTags: readonly string[], currentBaseline: string | null): string[];
-/**
- * Build a fork-status report from current state.
- */
-export interface ForkStatusReport {
-    readonly hasBaseline: boolean;
-    readonly baseline: ForkBaseline | null;
-    readonly syncCount: number;
-    readonly lastSync: ForkSyncRecord | null;
-    readonly driftWarning: boolean;
-}
-export declare function buildForkStatusReport(state: ForkState): ForkStatusReport;

package/dist/src/services/fork/fork-sync-state.js

@@ -1,130 +0,0 @@
-/**
- * v2.15.0 follow-up — G11: fork sync state service.
- *
- * Tracks the local fork's relationship to its upstream: which tag the
- * fork is based on, how many commits / files it has diverged, and a
- * history of past syncs. Persistence: `.peaks/fork-state.json` in the
- * project root.
- *
- * Pure functions on top of a typed state object. The CLI surfaces 5
- * commands (status / upstream-check / sync-plan / sync / sync-verify)
- * but the actual upstream fetch + merge is deferred to a follow-up
- * slice; this slice ships the model + the dry-run / plan / record path.
- */
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-export const EMPTY_FORK_STATE = {
-    version: 1,
-    baseline: null,
-    history: []
-};
-const STATE_FILE = '.peaks/fork-state.json';
-export function getForkStatePath(projectRoot) {
-    return resolve(projectRoot, STATE_FILE);
-}
-export function readForkState(projectRoot) {
-    const path = getForkStatePath(projectRoot);
-    if (!existsSync(path))
-        return EMPTY_FORK_STATE;
-    try {
-        const raw = readFileSync(path, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (parsed.version !== 1)
-            return EMPTY_FORK_STATE;
-        return {
-            version: 1,
-            baseline: parsed.baseline ?? null,
-            history: Array.isArray(parsed.history) ? parsed.history : []
-        };
-    }
-    catch {
-        return EMPTY_FORK_STATE;
-    }
-}
-export function writeForkState(projectRoot, state) {
-    const path = getForkStatePath(projectRoot);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify(state, null, 2), 'utf8');
-}
-/**
- * Record a new sync plan. The state is immutable; the returned state
- * has the new plan appended to `history`.
- */
-export function appendSyncRecord(state, record) {
-    return {
-        version: 1,
-        baseline: state.baseline,
-        history: [...state.history, record]
-    };
-}
-/**
- * Update an existing sync record's status (e.g. planned → verified).
- * Returns the state unchanged when the record is not found.
- */
-export function updateSyncRecordStatus(state, syncId, status, notes) {
-    let found = false;
-    const history = state.history.map((r) => {
-        if (r.syncId !== syncId)
-            return r;
-        found = true;
-        return {
-            ...r,
-            status,
-            ...(notes !== undefined ? { verificationNotes: notes } : {})
-        };
-    });
-    if (!found)
-        return state;
-    return { ...state, history };
-}
-/**
- * Generate a sync plan id from a target tag. Format:
- * `sync-<ISO-date>-<tag-sanitized>`.
- */
-export function makeSyncId(targetTag, now = new Date()) {
-    const date = now.toISOString().slice(0, 10);
-    const safeTag = targetTag.replace(/[^A-Za-z0-9._-]/g, '-');
-    return `sync-${date}-${safeTag}`;
-}
-/**
- * Recommend stable tags to sync to, given a list of available tags.
- * "Stable" = no pre-release suffix (no `-alpha`, `-beta`, `-rc`).
- * Picks the latest stable tag that is NEWER than the current baseline.
- */
-export function recommendStableTags(availableTags, currentBaseline) {
-    const isStable = (t) => !/(?:^|-)(?:alpha|beta|rc|dev|preview)/i.test(t);
-    const stable = availableTags.filter(isStable);
-    // Sort by semver-like order (best effort): split on '.', parse ints.
-    const cmp = (a, b) => {
-        // Strip leading 'v' before splitting on '.' or '-' so 'v1' → [1]
-        const toParts = (t) => t
-            .replace(/^v/i, '')
-            .split(/[.\-]/)
-            .map((s) => Number.parseInt(s, 10) || 0);
-        const pa = toParts(a);
-        const pb = toParts(b);
-        for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-            const da = pa[i] ?? 0;
-            const db = pb[i] ?? 0;
-            if (da !== db)
-                return da - db;
-        }
-        return 0;
-    };
-    stable.sort(cmp);
-    if (currentBaseline === null)
-        return stable;
-    const idx = stable.indexOf(currentBaseline);
-    return idx >= 0 ? stable.slice(idx + 1) : stable;
-}
-export function buildForkStatusReport(state) {
-    const lastSync = state.history.length > 0 ? state.history[state.history.length - 1] : null;
-    const drift = state.baseline !== null && state.baseline.commitsAhead > 30;
-    return {
-        hasBaseline: state.baseline !== null,
-        baseline: state.baseline,
-        syncCount: state.history.length,
-        lastSync,
-        driftWarning: drift
-    };
-}

package/dist/src/services/fuzzy-matching/fuzzy-match-service.d.ts

@@ -1,15 +0,0 @@
-import type { FuzzyMatchOptions, FuzzyMatchResult } from './types.js';
-/**
- * String-overload: when `items` is an array of strings, the searchable text
- * is the string itself. No keyFn is required.
- */
-export declare function fuzzyMatch<T extends string>(query: string, items: T[], options?: FuzzyMatchOptions): FuzzyMatchResult<T>[];
-/**
- * Object-overload: caller provides a `keyFn` that extracts the searchable
- * text from each item. The keyFn is invoked once per item per call; the
- * caller is responsible for ensuring the result is stable (e.g., don't
- * concatenate mutable fields).
- */
-export declare function fuzzyMatchWithKey<T>(query: string, items: T[], options: FuzzyMatchOptions & {
-    keyFn: (item: T) => string;
-}): FuzzyMatchResult<T>[];

package/dist/src/services/fuzzy-matching/fuzzy-match-service.js

@@ -1,56 +0,0 @@
-import { Fzf } from 'fzf';
-/**
- * Default limit for fuzzy-match. Aligned with the spec's "--limit default 6".
- */
-const DEFAULT_LIMIT = 6;
-/**
- * String-overload: when `items` is an array of strings, the searchable text
- * is the string itself. No keyFn is required.
- */
-export function fuzzyMatch(query, items, options = {}) {
-    return fuzzyMatchWithKey(query, items, { ...options, keyFn: (item) => item });
-}
-/**
- * Object-overload: caller provides a `keyFn` that extracts the searchable
- * text from each item. The keyFn is invoked once per item per call; the
- * caller is responsible for ensuring the result is stable (e.g., don't
- * concatenate mutable fields).
- */
-export function fuzzyMatchWithKey(query, items, options) {
-    const { keyFn } = options;
-    const limit = options.limit ?? DEFAULT_LIMIT;
-    if (items.length === 0)
-        return [];
-    // Empty query: surface all items (capped at limit) with neutral score and
-    // empty positions. Useful for "list" or "preview" use cases where the
-    // caller wants a deterministic top-N without a query.
-    if (query === '') {
-        return items.slice(0, limit).map((item) => ({ item, score: 0, positions: [] }));
-    }
-    const fzf = new Fzf(items, {
-        selector: keyFn,
-        limit,
-        // Per spec: default is case-insensitive (NOT fzf's smart-case).
-        // The user explicitly opts into case-sensitive via caseSensitive:true.
-        casing: options.caseSensitive === true ? 'case-sensitive' : 'case-insensitive',
-        // normalize:true (default) strips diacritics; fzf returns more matches
-        // for non-ASCII text this way, which is what we want for
-        // bilingual (zh-CN + en) memory entries.
-    });
-    const raw = fzf.find(query);
-    if (raw.length === 0)
-        return [];
-    // fzf-for-js score is "higher = better". Normalize so the top of the
-    // current batch is exactly 1.0 and others are in [0, 1].
-    // When the top score is 0 (degenerate — exact-character-only query that
-    // still matched somehow), fall back to 1.0 to avoid divide-by-zero.
-    const topScore = raw[0]?.score ?? 1;
-    const denom = topScore > 0 ? topScore : 1;
-    return raw.slice(0, limit).map((entry) => {
-        const score = topScore > 0 ? Number((entry.score / denom).toFixed(4)) : 1;
-        // positions is a Set<number> in fzf-for-js; convert to a sorted array
-        // so the JSON envelope is stable and human-readable.
-        const positions = [...entry.positions].sort((a, b) => a - b);
-        return { item: entry.item, score, positions };
-    });
-}

package/dist/src/services/fuzzy-matching/fzf-pick-service.d.ts

@@ -1,68 +0,0 @@
-/**
- * Generic fzf binary picker (slice 2026-06-14-fzf-headroom-rollout).
- *
- * Promoted from `src/services/slice/slice-pick-service.ts` (which is
- * the only prior caller). Encapsulates the canonical fzf integration
- * pattern: format items as one-line text, spawn `fzf --multi`, parse
- * the multi-selection, write a `<list-id>-picked.json` artifact.
- *
- * Two distinct things live in `src/services/fuzzy-matching/`:
- *  - `fuzzy-match-service.ts` — in-process fzf *npm package* (the
- *    Fzf class). Used by `memory search` / `retrospective search`.
- *  - `fzf-pick-service.ts`    — spawns the fzf *binary* for
- *    interactive TTY multi-select. Used by `peaks slice pick`,
- *    `peaks memory list --pick`, `peaks retrospective index --pick`.
- *
- * The two are independent (one is a library, the other spawns a CLI);
- * do not merge them. fzf-for-js returns positions; the binary returns
- * raw lines. Different output shapes → different consumers.
- *
- * Source-of-truth: the binary is the *consumer* of the formatter
- * output, not an input. Each caller injects its own `formatLine` and
- * `parseLine` so a future swap to skim/peco is a one-line change per
- * caller, not a refactor of this service.
- */
-export interface FzfPickOptions<T> {
-    readonly items: readonly T[];
-    /** Render a single item as one line of fzf input. Must round-trip with parseLine. */
-    readonly formatLine: (item: T) => string;
-    /** Reconstruct an item from a fzf output line. Return null to drop the line. */
-    readonly parseLine: (line: string) => T | null;
-    /** Absolute path for the output artifact. Caller decides the directory layout. */
-    readonly outputPath: string;
-    /** Metadata to embed in the picked artifact (rid, parentId, etc). */
-    readonly meta: Record<string, unknown>;
-    /** Run `fzf --preview 'cat'` (recommended; needs fzf >= 0.38). */
-    readonly preview?: boolean;
-    /** Override fzf binary path (default: 'fzf'). Useful for tests. */
-    readonly fzfBin?: string;
-    /** Override stdin content for tests; bypasses the actual spawning. */
-    readonly overrideStdin?: string;
-    /** Working directory for the fzf spawn. */
-    readonly projectRoot: string;
-    /** fzf --multi toggle (default true; pass false for single-select). */
-    readonly multi?: boolean;
-    /** Custom fzf prompt string (default "pick> "). */
-    readonly prompt?: string;
-}
-export interface FzfPickResult<T> {
-    readonly picked: readonly T[];
-    readonly outputPath: string;
-    readonly fzfVersion: string;
-}
-export declare const MIN_FZF_VERSION = "0.38";
-/**
- * Pick a subset of `items` interactively via fzf. The full flow:
- *   1. Check fzf presence + version.
- *   2. Format items as one-line text (caller's formatLine).
- *   3. Spawn `fzf --multi` (or test override).
- *   4. Parse the multi-selection back into T[] (caller's parseLine).
- *   5. Write `<outputPath>` with the picked + meta + fzfVersion.
- *
- * Failure modes:
- *   - fzf missing → throws with `brew install fzf | apt-get install fzf` hint.
- *   - fzf version too old → throws.
- *   - fzf exits 130 (Esc) → returns `{ picked: [], outputPath, fzfVersion }` (NOT thrown).
- *   - parseLine returns null for a line → silently dropped (line ignored).
- */
-export declare function pickFromList<T>(options: FzfPickOptions<T>): Promise<FzfPickResult<T>>;