pulse-framework-cli 0.4.1

package/dist/lib/briefing.js

@@ -0,0 +1,231 @@
+"use strict";
+/**
+ * Briefing Library - Aggregates data for Decision Briefings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateScopeCheck = calculateScopeCheck;
+exports.calculateRiskSummary = calculateRiskSummary;
+exports.calculateTimeSummary = calculateTimeSummary;
+exports.generateRecommendation = generateRecommendation;
+exports.renderProgressBar = renderProgressBar;
+exports.renderBriefing = renderBriefing;
+/**
+ * Calculate scope check against preset limits
+ */
+function calculateScopeCheck(config, stats) {
+    const totalLines = stats.linesAdded + stats.linesDeleted;
+    const files = {
+        current: stats.filesChanged,
+        max: config.thresholds.warnMaxFilesChanged,
+        percent: Math.round((stats.filesChanged / config.thresholds.warnMaxFilesChanged) * 100),
+    };
+    const lines = {
+        current: totalLines,
+        max: config.thresholds.warnMaxLinesChanged,
+        percent: Math.round((totalLines / config.thresholds.warnMaxLinesChanged) * 100),
+    };
+    const deletes = {
+        current: stats.linesDeleted,
+        max: config.thresholds.warnMaxDeletions,
+        percent: Math.round((stats.linesDeleted / config.thresholds.warnMaxDeletions) * 100),
+    };
+    const exceededFields = [];
+    if (files.percent > 100)
+        exceededFields.push("files");
+    if (lines.percent > 100)
+        exceededFields.push("lines");
+    if (deletes.percent > 100)
+        exceededFields.push("deletes");
+    return {
+        files,
+        lines,
+        deletes,
+        exceeded: exceededFields.length > 0,
+        exceededFields,
+    };
+}
+/**
+ * Summarize risks from scan results
+ */
+function calculateRiskSummary(scanResult) {
+    const criticalCount = scanResult.findings.filter((f) => f.severity === "critical").length;
+    const warningCount = scanResult.findings.filter((f) => f.severity === "warn").length;
+    const loopSignals = scanResult.findings
+        .filter((f) => f.code === "LOOP_SIGNAL")
+        .map((f) => f.message);
+    let loopRisk = "LOW";
+    if (loopSignals.length >= 3) {
+        loopRisk = "HIGH";
+    }
+    else if (loopSignals.length >= 1) {
+        loopRisk = "MEDIUM";
+    }
+    return {
+        criticalCount,
+        warningCount,
+        findings: scanResult.findings,
+        loopRisk,
+        loopSignals,
+    };
+}
+/**
+ * Calculate time-based metrics
+ */
+function calculateTimeSummary(lastCheckpointAt, checkpointReminderMinutes) {
+    const now = Date.now();
+    let minutesSinceCheckpoint = null;
+    let checkpointOverdue = false;
+    if (lastCheckpointAt) {
+        const lastCp = Date.parse(lastCheckpointAt);
+        if (Number.isFinite(lastCp)) {
+            minutesSinceCheckpoint = Math.floor((now - lastCp) / 60000);
+            checkpointOverdue = minutesSinceCheckpoint > checkpointReminderMinutes;
+        }
+    }
+    return {
+        minutesSinceCheckpoint,
+        checkpointOverdue,
+        sessionMinutes: minutesSinceCheckpoint, // For now, same as checkpoint
+    };
+}
+/**
+ * Generate recommendation based on all factors
+ */
+function generateRecommendation(scope, risk, time) {
+    // Critical findings = STOP
+    if (risk.criticalCount > 0) {
+        return {
+            action: "stop",
+            reason: `${risk.criticalCount} Critical Finding(s) - Fix vor Merge`,
+            command: "pulse doctor",
+        };
+    }
+    // High loop risk = Escalate
+    if (risk.loopRisk === "HIGH") {
+        return {
+            action: "escalate",
+            reason: "High loop risk detected",
+            command: "pulse escalate",
+        };
+    }
+    // Scope exceeded significantly = Checkpoint
+    if (scope.exceeded && scope.lines.percent > 150) {
+        return {
+            action: "checkpoint",
+            reason: `Scope exceeded (${scope.lines.current}/${scope.lines.max} Lines)`,
+            command: "pulse checkpoint -m 'wip: progress'",
+        };
+    }
+    // Checkpoint overdue = Checkpoint
+    if (time.checkpointOverdue) {
+        return {
+            action: "checkpoint",
+            reason: `${time.minutesSinceCheckpoint} min since last checkpoint`,
+            command: "pulse checkpoint -m 'wip: progress'",
+        };
+    }
+    // Medium loop risk = Checkpoint
+    if (risk.loopRisk === "MEDIUM") {
+        return {
+            action: "checkpoint",
+            reason: "Loop signals detected - checkpoint recommended",
+            command: "pulse checkpoint -m 'wip: checkpoint before continuing'",
+        };
+    }
+    // Warnings but manageable = Approve with note
+    if (risk.warningCount > 0) {
+        return {
+            action: "approve",
+            reason: `${risk.warningCount} Warning(s) - Approve with reservations`,
+        };
+    }
+    // All good
+    return {
+        action: "approve",
+        reason: "No findings, scope OK",
+    };
+}
+/**
+ * Render progress bar
+ */
+function renderProgressBar(percent, width = 15) {
+    const filled = Math.min(width, Math.round((percent / 100) * width));
+    const empty = width - filled;
+    const bar = "█".repeat(filled) + "░".repeat(empty);
+    return bar;
+}
+/**
+ * Render full Decision Briefing to terminal
+ */
+function renderBriefing(briefing) {
+    const lines = [];
+    const boxWidth = 55;
+    const hr = "─".repeat(boxWidth);
+    lines.push(`┌${"─".repeat(boxWidth)}┐`);
+    lines.push(`│ PULSE Review – Decision Briefing${" ".repeat(boxWidth - 35)}│`);
+    lines.push(`├${hr}┤`);
+    // Preset + Profile
+    const presetProfile = briefing.preset
+        ? `${briefing.preset}/${briefing.profile}`
+        : briefing.profile;
+    lines.push(`│ Profile: ${presetProfile}${" ".repeat(boxWidth - 11 - presetProfile.length)}│`);
+    lines.push(`├${hr}┤`);
+    // Scope Check
+    lines.push(`│ SCOPE-CHECK${" ".repeat(boxWidth - 12)}│`);
+    const { scope } = briefing;
+    const filesBar = renderProgressBar(scope.files.percent);
+    const linesBar = renderProgressBar(scope.lines.percent);
+    const deletesBar = renderProgressBar(scope.deletes.percent);
+    const filesLine = `  Files: ${scope.files.current}/${scope.files.max} (${scope.files.percent}%)  ${filesBar}`;
+    const linesLine = `  Lines: ${scope.lines.current}/${scope.lines.max} (${scope.lines.percent}%)  ${linesBar}`;
+    const deletesLine = `  Deletes: ${scope.deletes.current}/${scope.deletes.max} (${scope.deletes.percent}%)  ${deletesBar}`;
+    lines.push(`│${filesLine}${" ".repeat(Math.max(0, boxWidth - filesLine.length))}│`);
+    lines.push(`│${linesLine}${" ".repeat(Math.max(0, boxWidth - linesLine.length))}│`);
+    lines.push(`│${deletesLine}${" ".repeat(Math.max(0, boxWidth - deletesLine.length))}│`);
+    if (scope.exceeded) {
+        const warn = `  ⚠️ Exceeded: ${scope.exceededFields.join(", ")}`;
+        lines.push(`│${warn}${" ".repeat(Math.max(0, boxWidth - warn.length))}│`);
+    }
+    lines.push(`├${hr}┤`);
+    // Risk Summary
+    lines.push(`│ RISK-SUMMARY${" ".repeat(boxWidth - 13)}│`);
+    const { risk, time } = briefing;
+    if (risk.criticalCount > 0) {
+        const crit = `  🚨 ${risk.criticalCount} Critical`;
+        lines.push(`│${crit}${" ".repeat(Math.max(0, boxWidth - crit.length))}│`);
+    }
+    if (risk.warningCount > 0) {
+        const warn = `  ⚠️ ${risk.warningCount} Warnings`;
+        lines.push(`│${warn}${" ".repeat(Math.max(0, boxWidth - warn.length))}│`);
+    }
+    if (risk.criticalCount === 0 && risk.warningCount === 0) {
+        const ok = `  ✅ No findings`;
+        lines.push(`│${ok}${" ".repeat(Math.max(0, boxWidth - ok.length))}│`);
+    }
+    const timeStr = time.minutesSinceCheckpoint !== null
+        ? `  ⏱️ Checkpoint ${time.minutesSinceCheckpoint} min ago`
+        : `  ⏱️ No checkpoint`;
+    lines.push(`│${timeStr}${" ".repeat(Math.max(0, boxWidth - timeStr.length))}│`);
+    const loopEmoji = risk.loopRisk === "HIGH" ? "🔴" : risk.loopRisk === "MEDIUM" ? "🟡" : "🟢";
+    const loopStr = `  ${loopEmoji} Loop Risk: ${risk.loopRisk}`;
+    lines.push(`│${loopStr}${" ".repeat(Math.max(0, boxWidth - loopStr.length))}│`);
+    lines.push(`├${hr}┤`);
+    // Recommendation
+    const { recommendation } = briefing;
+    const actionEmoji = {
+        approve: "✅",
+        checkpoint: "⏱️",
+        escalate: "🚨",
+        stop: "🛑",
+    }[recommendation.action];
+    const recLine = `${actionEmoji} RECOMMENDATION: ${recommendation.action.toUpperCase()}`;
+    lines.push(`│ ${recLine}${" ".repeat(Math.max(0, boxWidth - recLine.length - 1))}│`);
+    const reasonLine = `  → ${recommendation.reason}`;
+    lines.push(`│${reasonLine}${" ".repeat(Math.max(0, boxWidth - reasonLine.length))}│`);
+    if (recommendation.command) {
+        const cmdLine = `  → ${recommendation.command}`;
+        lines.push(`│${cmdLine}${" ".repeat(Math.max(0, boxWidth - cmdLine.length))}│`);
+    }
+    lines.push(`└${"─".repeat(boxWidth)}┘`);
+    return lines.join("\n");
+}

package/dist/lib/clipboard.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copy text to system clipboard (cross-platform)
+ * Returns true if successful, false otherwise
+ */
+export declare function copyToClipboard(text: string): Promise<boolean>;
+/**
+ * Copy text to clipboard and return status message
+ */
+export declare function copyAndNotify(text: string): Promise<string>;

package/dist/lib/clipboard.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyToClipboard = copyToClipboard;
+exports.copyAndNotify = copyAndNotify;
+const node_os_1 = __importDefault(require("node:os"));
+/**
+ * Copy text to system clipboard (cross-platform)
+ * Returns true if successful, false otherwise
+ */
+async function copyToClipboard(text) {
+    const platform = node_os_1.default.platform();
+    try {
+        if (platform === "darwin") {
+            // macOS: pbcopy
+            await execWithStdin("pbcopy", [], text);
+            return true;
+        }
+        if (platform === "win32") {
+            // Windows: clip
+            await execWithStdin("clip", [], text);
+            return true;
+        }
+        if (platform === "linux") {
+            // Linux: try xclip, then xsel
+            try {
+                await execWithStdin("xclip", ["-selection", "clipboard"], text);
+                return true;
+            }
+            catch {
+                try {
+                    await execWithStdin("xsel", ["--clipboard", "--input"], text);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Execute a command with stdin input
+ */
+async function execWithStdin(cmd, args, input) {
+    const { spawn } = await Promise.resolve().then(() => __importStar(require("node:child_process")));
+    return new Promise((resolve, reject) => {
+        const proc = spawn(cmd, args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        proc.on("error", reject);
+        proc.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`${cmd} exited with code ${code}`));
+            }
+        });
+        proc.stdin?.write(input);
+        proc.stdin?.end();
+    });
+}
+/**
+ * Copy text to clipboard and return status message
+ */
+async function copyAndNotify(text) {
+    const success = await copyToClipboard(text);
+    if (success) {
+        return "📋 In Zwischenablage kopiert!";
+    }
+    const platform = node_os_1.default.platform();
+    if (platform === "linux") {
+        return "⚠️ Clipboard not available (xclip/xsel not installed)";
+    }
+    return "⚠️ Could not copy to clipboard";
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,14 @@
+import type { PulseConfig, PresetName, PresetConfig } from "./types.js";
+export declare const PRESETS: Record<PresetName, PresetConfig>;
+export declare const DEFAULT_CONFIG: PulseConfig;
+export declare function loadConfig(repoRoot: string): Promise<PulseConfig>;
+export declare function writeDefaultConfig(repoRoot: string): Promise<void>;
+export declare function normalizeConfig(input: any): PulseConfig;
+/**
+ * Get all available preset names
+ */
+export declare function getPresetNames(): PresetName[];
+/**
+ * Get preset configuration by name
+ */
+export declare function getPreset(name: PresetName): PresetConfig;

package/dist/lib/config.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = exports.PRESETS = void 0;
+exports.loadConfig = loadConfig;
+exports.writeDefaultConfig = writeDefaultConfig;
+exports.normalizeConfig = normalizeConfig;
+exports.getPresetNames = getPresetNames;
+exports.getPreset = getPreset;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const paths_js_1 = require("./paths.js");
+// ════════════════════════════════════════════════════════════════════════════
+// TEAM PRESETS
+// ════════════════════════════════════════════════════════════════════════════
+exports.PRESETS = {
+    frontend: {
+        warnMaxFilesChanged: 10,
+        warnMaxLinesChanged: 200,
+        warnMaxDeletions: 30,
+        checkpointReminderMinutes: 20,
+        extraSecretPatterns: [
+            "NEXT_PUBLIC_",
+            "VITE_",
+        ],
+    },
+    backend: {
+        warnMaxFilesChanged: 15,
+        warnMaxLinesChanged: 400,
+        warnMaxDeletions: 50,
+        checkpointReminderMinutes: 30,
+        extraSecretPatterns: [
+            "DATABASE_URL",
+            "REDIS_URL",
+            "SMTP_",
+        ],
+    },
+    fullstack: {
+        warnMaxFilesChanged: 20,
+        warnMaxLinesChanged: 500,
+        warnMaxDeletions: 60,
+        checkpointReminderMinutes: 25,
+    },
+    monorepo: {
+        warnMaxFilesChanged: 30,
+        warnMaxLinesChanged: 800,
+        warnMaxDeletions: 100,
+        checkpointReminderMinutes: 30,
+    },
+    custom: {
+        warnMaxFilesChanged: 15,
+        warnMaxLinesChanged: 300,
+        warnMaxDeletions: 50,
+        checkpointReminderMinutes: 30,
+    },
+};
+exports.DEFAULT_CONFIG = {
+    version: 1,
+    projectType: "unknown",
+    enforcement: "mixed",
+    notifications: "both",
+    thresholds: {
+        warnMaxFilesChanged: 15,
+        warnMaxLinesChanged: 300,
+        warnMaxDeletions: 50,
+    },
+    patterns: {
+        // Keep these as regex source strings (without surrounding / /).
+        // We intentionally include a few high-signal patterns + a generic catch-all.
+        secret: [
+            "AKIA[0-9A-Z]{16}", // AWS access key id
+            "ASIA[0-9A-Z]{16}", // AWS temporary key id
+            "ghp_[A-Za-z0-9]{36}", // GitHub classic token
+            "github_pat_[A-Za-z0-9_]{80,}", // GitHub fine-grained token
+            "sk_(live|test)_[A-Za-z0-9]{16,}", // Stripe
+            "AIzaSy[A-Za-z0-9_-]{30,}", // Google API key
+            "(?i)(api[_-]?key|secret|token|password)\\s*[:=]\\s*['\\\"][^'\\\"]{8,}['\\\"]", // generic
+            "(?i)-----BEGIN (RSA|EC|OPENSSH) PRIVATE KEY-----",
+        ],
+        prodUrl: [
+            // any http(s) URL that isn't localhost or example domains
+            "https?://(?!localhost\\b)(?!127\\.0\\.0\\.1\\b)(?!0\\.0\\.0\\.0\\b)(?!example\\.com\\b)[^\\s'\\\"]+",
+        ],
+    },
+    commands: {
+        test: "",
+    },
+};
+async function loadConfig(repoRoot) {
+    const p = (0, paths_js_1.configFile)(repoRoot);
+    try {
+        const raw = await promises_1.default.readFile(p, "utf8");
+        const parsed = JSON.parse(raw);
+        return normalizeConfig(parsed);
+    }
+    catch {
+        return exports.DEFAULT_CONFIG;
+    }
+}
+async function writeDefaultConfig(repoRoot) {
+    const p = (0, paths_js_1.configFile)(repoRoot);
+    await promises_1.default.writeFile(p, JSON.stringify(exports.DEFAULT_CONFIG, null, 2) + "\n", "utf8");
+}
+function normalizeConfig(input) {
+    // Apply preset defaults first if preset is set
+    const presetName = input?.preset;
+    const presetDefaults = presetName && exports.PRESETS[presetName] ? exports.PRESETS[presetName] : null;
+    const merged = {
+        ...exports.DEFAULT_CONFIG,
+        ...(typeof input === "object" && input ? input : {}),
+        thresholds: {
+            ...exports.DEFAULT_CONFIG.thresholds,
+            // Apply preset thresholds
+            ...(presetDefaults ? {
+                warnMaxFilesChanged: presetDefaults.warnMaxFilesChanged,
+                warnMaxLinesChanged: presetDefaults.warnMaxLinesChanged,
+                warnMaxDeletions: presetDefaults.warnMaxDeletions,
+            } : {}),
+            // User overrides take precedence
+            ...(input?.thresholds ?? {}),
+        },
+        patterns: {
+            ...exports.DEFAULT_CONFIG.patterns,
+            ...(input?.patterns ?? {}),
+            // Merge extra secret patterns from preset
+            secret: [
+                ...exports.DEFAULT_CONFIG.patterns.secret,
+                ...(presetDefaults?.extraSecretPatterns ?? []),
+                ...(input?.patterns?.secret ?? []),
+            ],
+        },
+        commands: {
+            ...exports.DEFAULT_CONFIG.commands,
+            ...(input?.commands ?? {}),
+        },
+        // Apply preset checkpoint reminder
+        checkpointReminderMinutes: input?.checkpointReminderMinutes
+            ?? presetDefaults?.checkpointReminderMinutes
+            ?? 30,
+    };
+    // Defensive: ensure required shapes
+    merged.version = 1;
+    merged.preset = presetName;
+    if (!["advisory", "mixed", "strict"].includes(merged.enforcement)) {
+        merged.enforcement = exports.DEFAULT_CONFIG.enforcement;
+    }
+    if (!["terminal", "macos", "both"].includes(merged.notifications)) {
+        merged.notifications = exports.DEFAULT_CONFIG.notifications;
+    }
+    if (!["node", "python", "unknown"].includes(merged.projectType)) {
+        merged.projectType = exports.DEFAULT_CONFIG.projectType;
+    }
+    return merged;
+}
+/**
+ * Get all available preset names
+ */
+function getPresetNames() {
+    return Object.keys(exports.PRESETS);
+}
+/**
+ * Get preset configuration by name
+ */
+function getPreset(name) {
+    return exports.PRESETS[name] ?? exports.PRESETS.custom;
+}

package/dist/lib/context-export.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Context Export - Selective file export for escalation
+ */
+export type FileExport = {
+    path: string;
+    content: string;
+    lines: number;
+};
+export type ContextExport = {
+    files: FileExport[];
+    totalFiles: number;
+    totalLines: number;
+    truncated: boolean;
+};
+/**
+ * Read and export specific files
+ */
+export declare function exportFiles(repoRoot: string, patterns: string[]): Promise<ContextExport>;
+/**
+ * Auto-detect relevant files from git diff
+ */
+export declare function autoDetectFiles(repoRoot: string, diffNameStatus: string): Promise<string[]>;
+/**
+ * Render context export as markdown
+ */
+export declare function renderContextExport(ctx: ContextExport): string;
+/**
+ * Render context export in XML-style for AI models
+ */
+export declare function renderContextExportXml(ctx: ContextExport): string;