peaks-loop 3.0.0

package/dist/src/services/impact/impact-scan-service.js

@@ -0,0 +1,197 @@
+/**
+ * v2.15.0 follow-up — G13: impact scan service.
+ *
+ * Lightweight, file-glob-based impact analysis (no AST, no type
+ * checking). For a given set of changed files, predict:
+ *   - which other files are likely affected (by path convention)
+ *   - which business flows touch them (config-driven)
+ *   - the risk level (high / medium / low)
+ *   - the "must-check" list (concrete business scenarios the user
+ *     must verify before shipping)
+ *
+ * Pure functions. The CLI wraps this with a `peaks impact scan`
+ * command; `peaks impact must-check` returns the must-check list
+ * subset. Persistence is per-invocation (no state file).
+ */
+/**
+ * Default business flow map (covers the most common B-end
+ * archetypes; users can override via --flows in the CLI).
+ */
+export const DEFAULT_BUSINESS_FLOWS = new Map([
+    ['用户管理', ['**/user/**', '**/users/**', '**/account/**']],
+    ['权限校验', ['**/auth/**', '**/permission/**', '**/rbac/**', '**/role/**']],
+    ['登录流程', ['**/login/**', '**/signin/**', '**/auth/**']],
+    ['订单/交易', ['**/order/**', '**/payment/**', '**/transaction/**', '**/checkout/**']],
+    ['Skill 权限', ['**/skill/**', '**/plugin/**']],
+    ['数据列表', ['**/list/**', '**/table/**', '**/grid/**']],
+    ['API 网关', ['**/api/**', '**/gateway/**', '**/routes/**']],
+    ['数据库 schema', ['**/schema/**', '**/migrations/**', '**/prisma/**', '**/drizzle/**']],
+    ['前端 UI 组件', ['**/components/**', '**/pages/**', '**/views/**']],
+    ['后端服务', ['**/services/**', '**/server/**', '**/controllers/**']]
+]);
+/**
+ * Convert a file path to a glob-friendly pattern. Returns 3 levels
+ * (the file itself, the parent dir, the project-wide pattern).
+ */
+function pathToGlobs(path) {
+    const normalized = path.replace(/\\/g, '/');
+    const parts = normalized.split('/');
+    // Drop the filename → get the parent pattern: "src/foo/" → "src/**"
+    const parent = parts.length > 1 ? parts.slice(0, -1).join('/') + '/**' : '**';
+    return [normalized, parent, `**/${parts[parts.length - 1]}`];
+}
+/** Simple glob matcher supporting `**` and `*`. */
+export function matchGlob(pattern, path) {
+    const normalizedPath = path.replace(/\\/g, '/');
+    // Build regex by splitting on glob tokens, escaping the rest.
+    // Order: ** (doublestar) → .* ; * → [^/]* ; other → escape
+    let regexStr = '';
+    let i = 0;
+    while (i < pattern.length) {
+        if (pattern[i] === '*' && pattern[i + 1] === '*') {
+            // ** may be followed by a slash — consume `**/` or just `**`
+            regexStr += '.*';
+            i += 2;
+            if (pattern[i] === '/')
+                i++;
+        }
+        else if (pattern[i] === '*') {
+            regexStr += '[^/]*';
+            i++;
+        }
+        else {
+            // Escape regex special char
+            regexStr += pattern[i].replace(/[.+^${}()|[\]\\]/g, '\\$&');
+            i++;
+        }
+    }
+    const re = new RegExp('^' + regexStr + '$');
+    return re.test(normalizedPath);
+}
+/** Risk of a single file based on its path patterns. */
+function fileRisk(path) {
+    if (matchGlob('**/auth/**', path) || matchGlob('**/permission/**', path) ||
+        matchGlob('**/rbac/**', path) || matchGlob('**/schema/**', path) ||
+        matchGlob('**/migrations/**', path) || matchGlob('**/prisma/**', path)) {
+        return 'high';
+    }
+    if (matchGlob('**/services/**', path) || matchGlob('**/api/**', path) ||
+        matchGlob('**/components/**', path)) {
+        return 'medium';
+    }
+    return 'low';
+}
+/**
+ * Run an impact scan. Pure function — no I/O.
+ */
+export function runImpactScan(opts) {
+    const flows = opts.businessFlows ?? DEFAULT_BUSINESS_FLOWS;
+    const changed = opts.changedFiles;
+    const warnings = [];
+    if (changed.length === 0) {
+        warnings.push('No changed files provided. Pass --files a.ts,b.ts to scan.');
+    }
+    // Build set of globs from changed files.
+    const changedGlobs = new Set();
+    for (const f of changed) {
+        for (const g of pathToGlobs(f))
+            changedGlobs.add(g);
+    }
+    // For each business flow, check if any changed file matches.
+    const affectedFlows = [];
+    for (const [name, patterns] of flows) {
+        const matches = changed.filter((f) => patterns.some((p) => matchGlob(p, f)));
+        if (matches.length > 0) {
+            affectedFlows.push({ name, reason: `changes touch ${matches.length} file(s) in this flow: ${matches.slice(0, 3).join(', ')}` });
+        }
+    }
+    // Predict other files that may be affected (siblings of changed files).
+    const impactedFiles = [];
+    for (const f of changed) {
+        const parts = f.replace(/\\/g, '/').split('/');
+        if (parts.length <= 1)
+            continue;
+        const parent = parts.slice(0, -1).join('/');
+        impactedFiles.push({
+            path: `${parent}/index.{ts,tsx,js,jsx}`,
+            reason: `sibling of changed file ${f}`,
+            risk: fileRisk(`${parent}/index.ts`)
+        });
+    }
+    // Deduplicate impacted files.
+    const seen = new Set();
+    const dedupedImpacted = impactedFiles.filter((f) => {
+        if (seen.has(f.path))
+            return false;
+        seen.add(f.path);
+        return true;
+    });
+    // Build must-check list.
+    const mustCheck = [];
+    for (const flow of affectedFlows) {
+        if (flow.name === '权限校验' || flow.name === '用户管理' || flow.name === '数据库 schema') {
+            mustCheck.push({
+                scenario: `回归测试: ${flow.name} 主流程跑通,边界 case(无权限/越权/迁移)不报错`,
+                category: 'business',
+                priority: 'P0'
+            });
+        }
+        if (flow.name === '登录流程') {
+            mustCheck.push({
+                scenario: '登录 / 登出 / 续签 / 失败提示 4 个流程手工跑一遍',
+                category: 'integration',
+                priority: 'P0'
+            });
+        }
+        if (flow.name === '前端 UI 组件' || flow.name === '数据列表') {
+            mustCheck.push({
+                scenario: `改动的 UI 页面在 3 种浏览器(Chrome / Edge / Safari)渲染正常,无白屏 / 错位 / 性能退化`,
+                category: 'ui',
+                priority: 'P1'
+            });
+        }
+        if (flow.name === 'API 网关' || flow.name === '后端服务') {
+            mustCheck.push({
+                scenario: `改动接口的 happy path + 3 个异常 case(超时/限流/鉴权失败)返回正确的 status code`,
+                category: 'integration',
+                priority: 'P0'
+            });
+        }
+    }
+    // Deduplicate by scenario.
+    const seenScenarios = new Set();
+    const dedupedMustCheck = mustCheck.filter((m) => {
+        if (seenScenarios.has(m.scenario))
+            return false;
+        seenScenarios.add(m.scenario);
+        return true;
+    });
+    // Overall risk = highest individual risk.
+    let overallRisk = 'low';
+    for (const f of dedupedImpacted) {
+        if (f.risk === 'high') {
+            overallRisk = 'high';
+            break;
+        }
+        if (f.risk === 'medium')
+            overallRisk = 'medium';
+    }
+    if (affectedFlows.length > 3)
+        overallRisk = 'high';
+    if (changed.length > 20)
+        overallRisk = 'high';
+    return {
+        changedFiles: changed,
+        impactedFiles: dedupedImpacted,
+        affectedFlows,
+        mustCheck: dedupedMustCheck,
+        overallRisk,
+        warnings
+    };
+}
+/**
+ * Extract just the must-check list from a scan report.
+ */
+export function mustCheckFromReport(report) {
+    return report.mustCheck;
+}

package/dist/src/services/legacy/legacy-detector.d.ts

@@ -0,0 +1,34 @@
+/**
+ * v2.15.0 follow-up — G8: legacy code detector.
+ *
+ * 12 Gaps memory: when peaks-cli is applied to a 存量老项目 (legacy
+ * codebase), it is helpful to surface a quick inventory of "what
+ * smells old" so the LLM / operator knows where to focus.
+ *
+ * Heuristics (intentionally light, since the user is Senior FE and
+ * the AI is the integrator):
+ *   - TODO / FIXME / HACK comments
+ *   - console.log calls (debug leftover)
+ *   - any-type TypeScript annotations (`as any`, `: any`)
+ *   - large files (> 500 lines)
+ *   - ts-ignore / @ts-expect-error (suppressed type errors)
+ *
+ * Pure function. No I/O. The CLI is `peaks legacy detect`.
+ */
+export type LegacyKind = 'todo' | 'console-log' | 'any-type' | 'large-file' | 'ts-ignore' | 'fixme' | 'hack';
+export interface LegacyFinding {
+    readonly kind: LegacyKind;
+    readonly file: string;
+    /** Line number, or null when the finding is file-level (e.g. large-file). */
+    readonly line: number | null;
+    /** A short excerpt of the offending line. */
+    readonly excerpt: string;
+}
+export interface LegacyReport {
+    readonly projectRoot: string;
+    readonly scannedFiles: number;
+    readonly findings: readonly LegacyFinding[];
+    readonly summary: Record<LegacyKind, number>;
+    readonly smells: 'low' | 'medium' | 'high';
+}
+export declare function detectLegacy(projectRoot: string, dir?: string): LegacyReport;

package/dist/src/services/legacy/legacy-detector.js

@@ -0,0 +1,111 @@
+/**
+ * v2.15.0 follow-up — G8: legacy code detector.
+ *
+ * 12 Gaps memory: when peaks-cli is applied to a 存量老项目 (legacy
+ * codebase), it is helpful to surface a quick inventory of "what
+ * smells old" so the LLM / operator knows where to focus.
+ *
+ * Heuristics (intentionally light, since the user is Senior FE and
+ * the AI is the integrator):
+ *   - TODO / FIXME / HACK comments
+ *   - console.log calls (debug leftover)
+ *   - any-type TypeScript annotations (`as any`, `: any`)
+ *   - large files (> 500 lines)
+ *   - ts-ignore / @ts-expect-error (suppressed type errors)
+ *
+ * Pure function. No I/O. The CLI is `peaks legacy detect`.
+ */
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+const PATTERNS = [
+    { kind: 'todo', regex: /(?:\/\/|\/\*|<!--)\s*(?:TODO|FIXME|HACK|XXX)\b/i },
+    { kind: 'console-log', regex: /\bconsole\.(log|debug|info)\s*\(/ },
+    { kind: 'any-type', regex: /\b(?:as\s+any|:\s*any\b|<any>)/ },
+    { kind: 'ts-ignore', regex: /@ts-(?:ignore|expect-error|nocheck)/ }
+];
+const LARGE_FILE_LINES = 500;
+function scanFile(file) {
+    let content;
+    try {
+        content = readFileSync(file, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const lines = content.split('\n');
+    const findings = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const { kind, regex } of PATTERNS) {
+            if (regex.test(line)) {
+                findings.push({ kind, file, line: i + 1, excerpt: line.trim().slice(0, 120) });
+                break; // one finding per line (avoid double-counting)
+            }
+        }
+    }
+    if (lines.length > LARGE_FILE_LINES) {
+        findings.push({ kind: 'large-file', file, line: null, excerpt: `${lines.length} lines (> ${LARGE_FILE_LINES})` });
+    }
+    return findings;
+}
+function walkFiles(root, maxDepth = 8) {
+    const out = [];
+    function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.name === 'node_modules' || e.name === '.git' || e.name === 'dist' || e.name === 'node_modules' || e.name.startsWith('.'))
+                continue;
+            const full = join(dir, e.name);
+            if (e.isDirectory())
+                walk(full, depth + 1);
+            else if (e.isFile() && (e.name.endsWith('.ts') || e.name.endsWith('.js') || e.name.endsWith('.tsx') || e.name.endsWith('.jsx'))) {
+                out.push(full);
+            }
+        }
+    }
+    walk(root, 0);
+    return out;
+}
+export function detectLegacy(projectRoot, dir = 'src') {
+    const root = resolve(projectRoot, dir);
+    if (!existsSync(root)) {
+        const empty = { todo: 0, 'console-log': 0, 'any-type': 0, 'large-file': 0, 'ts-ignore': 0, fixme: 0, hack: 0 };
+        return { projectRoot, scannedFiles: 0, findings: [], summary: empty, smells: 'low' };
+    }
+    const files = walkFiles(root);
+    const findings = [];
+    for (const f of files) {
+        findings.push(...scanFile(f));
+    }
+    // Re-key console-log to match the union
+    const mapped = findings.map((f) => f.kind === 'console-log' ? { ...f, kind: 'console-log' } : f);
+    const summary = {
+        todo: 0, 'console-log': 0, 'any-type': 0, 'large-file': 0, 'ts-ignore': 0, fixme: 0, hack: 0
+    };
+    for (const f of mapped) {
+        // The todo pattern catches both TODO and FIXME/HACK; reflect into fixme/hack as well when applicable
+        if (f.kind === 'todo') {
+            const lc = f.excerpt.toLowerCase();
+            if (lc.includes('fixme'))
+                summary.fixme++;
+            else if (lc.includes('hack'))
+                summary.hack++;
+            else
+                summary.todo++;
+        }
+        else {
+            summary[f.kind]++;
+        }
+    }
+    const total = Object.values(summary).reduce((s, n) => s + n, 0);
+    const smells = total > 50 ? 'high' : total > 10 ? 'medium' : 'low';
+    return { projectRoot, scannedFiles: files.length, findings: mapped, summary, smells };
+}

package/dist/src/services/log/log-commands-service.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Service layer for `peaks log tail` and `peaks log ls` subcommands.
+ *
+ * Slice 2026-06-16-cli-logging (G4). Pure helpers that the
+ * commander layer in `src/cli/commands/log-commands.ts` wraps.
+ * Separated from `logger.ts` so the surface is small + testable
+ * without spinning up a Commander program.
+ *
+ * Both helpers default to the on-disk log dir (`resolveLogDir()`)
+ * but accept an `dirOverride` so tests can pin the home to a
+ * tempdir without monkey-patching `os.homedir()`.
+ */
+import { type LogEntry } from './logger.js';
+/**
+ * Return all `peaks-cli-*.log` files in the log dir, sorted by
+ * date descending (newest first). Returns `[]` when the dir is
+ * missing or unreadable. Non-matching entries (e.g. a stray
+ * README) are filtered out.
+ */
+export declare function listLogFiles(opts?: {
+    dirOverride?: string;
+}): string[];
+export type TailLogOptions = {
+    /** Number of trailing lines to return. Defaults to 50. */
+    lines?: number;
+    /** Override the clock for deterministic tests. */
+    now?: () => Date;
+    /** Override the log dir (used by tests). */
+    dirOverride?: string;
+    /** Override the date (PRD AC2: PEAKS_LOG_DATE_OVERRIDE). */
+    dateOverride?: string;
+    /**
+     * Slice 2026-06-23-audit-4th #B2: filter by batchId. When set,
+     * only entries whose `batchId` field matches are returned (and
+     * the trailing-window accounting respects the post-filter total
+     * so a busy day does not push old matching entries out of view).
+     */
+    batchId?: string;
+};
+export type TailLogResult = {
+    /** Absolute path to the file that was tailed, or null when no file exists. */
+    file: string | null;
+    /** The trailing entries (already trimmed to `lines`). */
+    entries: LogEntry[];
+    /** The total number of entries in the file (for header messaging). */
+    total: number;
+    /** When `batchId` filter is applied, the number of matches in the file. */
+    batchMatches?: number;
+};
+/**
+ * Read today's log file and return the last `lines` entries. When
+ * no file exists for the given date, returns `{ file: null, entries: [], total: 0 }`.
+ */
+export declare function tailLog(opts?: TailLogOptions): TailLogResult;

package/dist/src/services/log/log-commands-service.js

@@ -0,0 +1,83 @@
+/**
+ * Service layer for `peaks log tail` and `peaks log ls` subcommands.
+ *
+ * Slice 2026-06-16-cli-logging (G4). Pure helpers that the
+ * commander layer in `src/cli/commands/log-commands.ts` wraps.
+ * Separated from `logger.ts` so the surface is small + testable
+ * without spinning up a Commander program.
+ *
+ * Both helpers default to the on-disk log dir (`resolveLogDir()`)
+ * but accept an `dirOverride` so tests can pin the home to a
+ * tempdir without monkey-patching `os.homedir()`.
+ */
+import { readdirSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { buildLogFileName, readLogEntries, resolveLogDir } from './logger.js';
+const LOG_FILE_NAME_PATTERN = /^peaks-loop-\d{4}-\d{2}-\d{2}\.log$/;
+/**
+ * Return all `peaks-cli-*.log` files in the log dir, sorted by
+ * date descending (newest first). Returns `[]` when the dir is
+ * missing or unreadable. Non-matching entries (e.g. a stray
+ * README) are filtered out.
+ */
+export function listLogFiles(opts = {}) {
+    const logDir = opts.dirOverride ?? resolveLogDir();
+    if (!existsSync(logDir))
+        return [];
+    let names;
+    try {
+        names = readdirSync(logDir);
+    }
+    catch {
+        return [];
+    }
+    return names
+        .filter((name) => LOG_FILE_NAME_PATTERN.test(name))
+        .filter((name) => {
+        try {
+            return statSync(join(logDir, name)).isFile();
+        }
+        catch {
+            return false;
+        }
+    })
+        .sort()
+        .reverse();
+}
+/**
+ * Read today's log file and return the last `lines` entries. When
+ * no file exists for the given date, returns `{ file: null, entries: [], total: 0 }`.
+ */
+export function tailLog(opts = {}) {
+    const lines = opts.lines ?? 50;
+    const logDir = opts.dirOverride ?? resolveLogDir();
+    const now = opts.now ? opts.now() : new Date();
+    const dateForFile = opts.dateOverride !== undefined
+        ? new Date(`${opts.dateOverride}T00:00:00.000Z`)
+        : now;
+    const fileName = buildLogFileName(dateForFile);
+    const fullPath = join(logDir, fileName);
+    const allEntries = readLogEntries({
+        now: () => now,
+        ...(opts.dirOverride !== undefined ? { dirOverride: opts.dirOverride } : {}),
+        ...(opts.dateOverride !== undefined ? { dateOverride: opts.dateOverride } : {})
+    });
+    const total = allEntries.length;
+    if (total === 0) {
+        return { file: null, entries: [], total: 0 };
+    }
+    // Slice 2026-06-23-audit-4th #B2: batchId filter — apply AFTER the
+    // read but BEFORE the trailing window, so a single batch's
+    // interleaved log lines surface as a coherent sequence instead of
+    // being pushed out by sibling-batch lines.
+    const filtered = opts.batchId !== undefined
+        ? allEntries.filter((e) => e.batchId === opts.batchId)
+        : allEntries;
+    if (filtered.length === 0) {
+        return { file: fullPath, entries: [], total, batchMatches: 0 };
+    }
+    const trailing = filtered.slice(Math.max(0, filtered.length - lines));
+    return opts.batchId !== undefined
+        ? { file: fullPath, entries: trailing, total, batchMatches: filtered.length }
+        : { file: fullPath, entries: trailing, total };
+}

package/dist/src/services/log/logger.d.ts

@@ -0,0 +1,103 @@
+/**
+ * JSONL file logger for peaks-cli.
+ *
+ * Slice 2026-06-16-cli-logging (G1, G2, G5, G6, G7).
+ *
+ * Default-on file logging: every peaks-cli invocation writes a
+ * structured log entry to `<homedir>/.peaks/logs/peaks-cli-YYYY-MM-DD.log`
+ * (UTC date stamp). One JSON object per line.
+ *
+ * Hard contracts enforced here:
+ *  - stdout is NEVER touched by the logger (G7). Use the returned
+ *    `LogLine` string and pipe it to the file only.
+ *  - The log dir is created lazily on first write (G1).
+ *  - File mode is 0o600 on POSIX (R3). Windows uses ACLs and the
+ *    0o600 bit is a no-op there; the call is best-effort.
+ *  - All write paths go through `redact` so a leaked secret can
+ *    never reach disk (G6).
+ *  - The log level can be overridden via `PEAKS_LOG_LEVEL` (G3) and
+ *    `PEAKS_LOG_DATE_OVERRIDE` (AC2) for deterministic tests.
+ *
+ * No third-party deps (R1): `fs.appendFileSync` + `JSON.stringify`
+ * is enough; pino/winston are NOT pulled in.
+ */
+import { dirname } from 'node:path';
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export type LogEntry = {
+    ts: string;
+    level: LogLevel;
+    command: string;
+    msg: string;
+    sessionId?: string;
+    version?: string;
+    batchId?: string;
+    data?: Record<string, unknown>;
+};
+/**
+ * Returns the canonical log directory. On Windows, `homedir()` is
+ * `%USERPROFILE%`; on macOS / Linux, `$HOME`. The path is the
+ * user-global `~/.peaks/logs/` — never inside a project tree (NG6).
+ */
+export declare function resolveLogDir(): string;
+/**
+ * Returns the UTC date-stamped file name. `date` is injectable so
+ * tests can pin the date without monkey-patching `Date`.
+ */
+export declare function buildLogFileName(date: Date): string;
+export type WriteLogOptions = {
+    /** Override the clock for deterministic tests. Defaults to `new Date()`. */
+    now?: () => Date;
+    /**
+     * Override the log dir for tests. Defaults to `resolveLogDir()`.
+     * Allows the test harness to redirect to a temp dir without
+     * monkey-patching `os.homedir()`.
+     */
+    dirOverride?: string;
+    /**
+     * Override the date used for the file name + entry `ts`. The PRD
+     * AC2 contract is `PEAKS_LOG_DATE_OVERRIDE=YYYY-MM-DD`; the
+     * program-level flag plumbing in `program.ts` reads it and passes
+     * it down. The `now` option still drives the `ts` field, so the
+     * caller MUST pass a matching `Date` for the AC2 invariant.
+     */
+    dateOverride?: string;
+};
+/**
+ * Write a single JSONL log entry. Returns the absolute file path
+ * the entry was written to, or `null` when the entry was filtered
+ * out by the current log level.
+ *
+ * Failures inside the logger (mkdir, appendFile, chmod) are caught
+ * and swallowed: a logger that takes down the CLI is worse than a
+ * logger that drops a line. The swallow is intentional per the PRD
+ * non-goals (NG1: no remote ship; the user only ever sees a file
+ * they read directly).
+ */
+export declare function writeLogEntry(entry: LogEntry, opts?: WriteLogOptions): string | null;
+export type ReadLogOptions = {
+    now?: () => Date;
+    dirOverride?: string;
+    dateOverride?: string;
+};
+/**
+ * Read the current day's log file and return all parseable JSON
+ * entries. Malformed lines are skipped (the on-disk file is JSONL,
+ * but a crash mid-write can leave a partial line; we don't want
+ * that to break `peaks log tail`).
+ */
+export declare function readLogEntries(opts?: ReadLogOptions): LogEntry[];
+/**
+ * Print a log line to stderr IF the current process is in verbose
+ * mode (`--verbose` / `-v` / `PEAKS_LOG_LEVEL=debug`). This is the
+ * G3 opt-in channel: by default, stderr stays clean so the CLI's
+ * `--json` envelope is not contaminated.
+ *
+ * Returns `true` when the line was written; `false` otherwise. The
+ * caller can use the boolean to detect silent-failure patterns (a
+ * `peaks log tail` that prints nothing when the user expected a
+ * verbose stream).
+ */
+export declare function maybeWriteStderr(entry: LogEntry, opts: {
+    verbose: boolean;
+}): boolean;
+export { dirname };