pulse-framework-cli 0.4.1

package/dist/lib/context-export.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Context Export - Selective file export for escalation
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportFiles = exportFiles;
+exports.autoDetectFiles = autoDetectFiles;
+exports.renderContextExport = renderContextExport;
+exports.renderContextExportXml = renderContextExportXml;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const glob_1 = require("glob");
+const MAX_LINES_PER_FILE = 500;
+const MAX_TOTAL_LINES = 2000;
+/**
+ * Read and export specific files
+ */
+async function exportFiles(repoRoot, patterns) {
+    const files = [];
+    let totalLines = 0;
+    let truncated = false;
+    for (const pattern of patterns) {
+        // Resolve glob pattern
+        const matches = await (0, glob_1.glob)(pattern, {
+            cwd: repoRoot,
+            nodir: true,
+            ignore: ["node_modules/**", ".git/**", "dist/**", "build/**", ".pulse/**"],
+        });
+        for (const match of matches) {
+            if (totalLines >= MAX_TOTAL_LINES) {
+                truncated = true;
+                break;
+            }
+            try {
+                const fullPath = node_path_1.default.join(repoRoot, match);
+                const content = await promises_1.default.readFile(fullPath, "utf8");
+                const lines = content.split("\n").length;
+                // Truncate if too long
+                let exportContent = content;
+                if (lines > MAX_LINES_PER_FILE) {
+                    const truncLines = content.split("\n").slice(0, MAX_LINES_PER_FILE);
+                    exportContent = truncLines.join("\n") + `\n\n// ... truncated (${lines - MAX_LINES_PER_FILE} more lines)`;
+                    truncated = true;
+                }
+                files.push({
+                    path: match,
+                    content: exportContent,
+                    lines: Math.min(lines, MAX_LINES_PER_FILE),
+                });
+                totalLines += Math.min(lines, MAX_LINES_PER_FILE);
+            }
+            catch {
+                // Skip files that can't be read
+            }
+        }
+        if (truncated)
+            break;
+    }
+    return {
+        files,
+        totalFiles: files.length,
+        totalLines,
+        truncated,
+    };
+}
+/**
+ * Auto-detect relevant files from git diff
+ */
+async function autoDetectFiles(repoRoot, diffNameStatus) {
+    const files = [];
+    for (const line of diffNameStatus.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const parts = trimmed.split(/\s+/);
+        if (parts.length < 2)
+            continue;
+        const status = parts[0];
+        const file = parts[1];
+        // Include modified and added files
+        if ((status === "M" || status === "A") && file) {
+            // Skip non-code files
+            if (isCodeFile(file)) {
+                files.push(file);
+            }
+        }
+    }
+    return files;
+}
+/**
+ * Check if file is a code file
+ */
+function isCodeFile(filepath) {
+    const codeExtensions = [
+        ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+        ".py", ".rb", ".go", ".rs", ".java", ".kt",
+        ".c", ".cpp", ".h", ".hpp", ".cs",
+        ".vue", ".svelte", ".astro",
+        ".json", ".yaml", ".yml", ".toml",
+        ".sql", ".graphql", ".gql",
+        ".sh", ".bash", ".zsh",
+        ".css", ".scss", ".less",
+        ".html", ".xml",
+    ];
+    const ext = node_path_1.default.extname(filepath).toLowerCase();
+    return codeExtensions.includes(ext);
+}
+/**
+ * Render context export as markdown
+ */
+function renderContextExport(ctx) {
+    const lines = [];
+    lines.push(`## Kontext-Export`);
+    lines.push(``);
+    lines.push(`**${ctx.totalFiles} Dateien, ~${ctx.totalLines} Zeilen**`);
+    if (ctx.truncated) {
+        lines.push(`⚠️ Truncated (Limit: ${MAX_TOTAL_LINES} Zeilen)`);
+    }
+    lines.push(``);
+    for (const file of ctx.files) {
+        const ext = node_path_1.default.extname(file.path).slice(1) || "txt";
+        lines.push(`### \`${file.path}\` (${file.lines} Zeilen)`);
+        lines.push(``);
+        lines.push("```" + ext);
+        lines.push(file.content);
+        lines.push("```");
+        lines.push(``);
+    }
+    return lines.join("\n");
+}
+/**
+ * Render context export in XML-style for AI models
+ */
+function renderContextExportXml(ctx) {
+    const lines = [];
+    lines.push(`<context_export files="${ctx.totalFiles}" lines="${ctx.totalLines}"${ctx.truncated ? ' truncated="true"' : ''}>`);
+    lines.push(``);
+    for (const file of ctx.files) {
+        lines.push(`<file path="${file.path}" lines="${file.lines}">`);
+        lines.push(file.content);
+        lines.push(`</file>`);
+        lines.push(``);
+    }
+    lines.push(`</context_export>`);
+    return lines.join("\n");
+}

package/dist/lib/exec.d.ts

@@ -0,0 +1,9 @@
+export type ExecResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+};
+export declare function exec(file: string, args: string[], opts?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<ExecResult>;

package/dist/lib/exec.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exec = exec;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+async function exec(file, args, opts) {
+    try {
+        const { stdout, stderr } = await execFileAsync(file, args, {
+            cwd: opts?.cwd,
+            env: { ...process.env, ...(opts?.env ?? {}) },
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return { stdout: String(stdout), stderr: String(stderr), exitCode: 0 };
+    }
+    catch (err) {
+        return {
+            stdout: String(err?.stdout ?? ""),
+            stderr: String(err?.stderr ?? err?.message ?? ""),
+            exitCode: Number(err?.code ?? 1),
+        };
+    }
+}

package/dist/lib/git.d.ts

@@ -0,0 +1,24 @@
+export declare function gitCurrentBranch(repoRoot: string): Promise<string>;
+export declare function gitIsMainBranch(repoRoot: string): Promise<boolean>;
+export declare function gitCreateBranch(repoRoot: string, name: string): Promise<boolean>;
+export declare function git(repoRoot: string, args: string[]): Promise<{
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+export declare function gitStatusPorcelain(repoRoot: string): Promise<string>;
+export declare function gitLogOneline(repoRoot: string, n?: number): Promise<string>;
+export declare function gitDiffStat(repoRoot: string, opts?: {
+    staged?: boolean;
+}): Promise<string>;
+export declare function gitDiffNameStatus(repoRoot: string, opts?: {
+    staged?: boolean;
+}): Promise<string>;
+export declare function gitDiffNumstat(repoRoot: string, opts?: {
+    staged?: boolean;
+}): Promise<string>;
+export declare function gitDiffText(repoRoot: string, opts?: {
+    staged?: boolean;
+    maxLines?: number;
+}): Promise<string>;

package/dist/lib/git.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitCurrentBranch = gitCurrentBranch;
+exports.gitIsMainBranch = gitIsMainBranch;
+exports.gitCreateBranch = gitCreateBranch;
+exports.git = git;
+exports.gitStatusPorcelain = gitStatusPorcelain;
+exports.gitLogOneline = gitLogOneline;
+exports.gitDiffStat = gitDiffStat;
+exports.gitDiffNameStatus = gitDiffNameStatus;
+exports.gitDiffNumstat = gitDiffNumstat;
+exports.gitDiffText = gitDiffText;
+const exec_js_1 = require("./exec.js");
+// ════════════════════════════════════════════════════════════════════════════
+// Branch-Utilities
+// ════════════════════════════════════════════════════════════════════════════
+async function gitCurrentBranch(repoRoot) {
+    const res = await (0, exec_js_1.exec)("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: repoRoot });
+    return res.stdout.trim();
+}
+async function gitIsMainBranch(repoRoot) {
+    const branch = await gitCurrentBranch(repoRoot);
+    return ["main", "master", "develop", "development"].includes(branch.toLowerCase());
+}
+async function gitCreateBranch(repoRoot, name) {
+    const res = await (0, exec_js_1.exec)("git", ["checkout", "-b", name], { cwd: repoRoot });
+    return res.exitCode === 0;
+}
+async function git(repoRoot, args) {
+    const res = await (0, exec_js_1.exec)("git", args, { cwd: repoRoot });
+    return { ok: res.exitCode === 0, stdout: res.stdout, stderr: res.stderr, exitCode: res.exitCode };
+}
+async function gitStatusPorcelain(repoRoot) {
+    const res = await git(repoRoot, ["status", "--porcelain"]);
+    return res.stdout.trimEnd();
+}
+async function gitLogOneline(repoRoot, n = 5) {
+    const res = await git(repoRoot, ["log", "--oneline", `-${n}`]);
+    return res.stdout.trimEnd();
+}
+async function gitDiffStat(repoRoot, opts) {
+    const baseArgs = ["diff", "--stat"];
+    if (opts?.staged)
+        baseArgs.push("--staged");
+    const res = await git(repoRoot, baseArgs);
+    return res.stdout.trimEnd();
+}
+async function gitDiffNameStatus(repoRoot, opts) {
+    const baseArgs = ["diff", "--name-status"];
+    if (opts?.staged)
+        baseArgs.push("--staged");
+    const res = await git(repoRoot, baseArgs);
+    return res.stdout.trimEnd();
+}
+async function gitDiffNumstat(repoRoot, opts) {
+    const baseArgs = ["diff", "--numstat"];
+    if (opts?.staged)
+        baseArgs.push("--staged");
+    const res = await git(repoRoot, baseArgs);
+    return res.stdout.trimEnd();
+}
+async function gitDiffText(repoRoot, opts) {
+    const baseArgs = ["diff"];
+    if (opts?.staged)
+        baseArgs.push("--staged");
+    const res = await git(repoRoot, baseArgs);
+    if (opts?.maxLines && res.stdout) {
+        const lines = res.stdout.split("\n");
+        if (lines.length > opts.maxLines) {
+            return lines.slice(0, opts.maxLines).join("\n") + `\n\n... (truncated, ${lines.length - opts.maxLines} more lines)`;
+        }
+    }
+    return res.stdout;
+}

package/dist/lib/input.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Prompt for text input with optional default value
+ */
+export declare function promptText(label: string, defaultValue?: string): Promise<string>;
+/**
+ * Prompt for selection from a list of choices
+ */
+export declare function promptSelect(label: string, choices: Array<{
+    value: string;
+    label: string;
+}>, defaultValue?: string): Promise<string>;
+/**
+ * Prompt for yes/no confirmation
+ */
+export declare function promptConfirm(label: string, defaultYes?: boolean): Promise<boolean>;

package/dist/lib/input.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptText = promptText;
+exports.promptSelect = promptSelect;
+exports.promptConfirm = promptConfirm;
+const promises_1 = __importDefault(require("node:readline/promises"));
+/**
+ * Prompt for text input with optional default value
+ */
+async function promptText(label, defaultValue = "") {
+    const rl = promises_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const q = defaultValue ? `${label} (default: ${defaultValue}): ` : `${label}: `;
+        const ans = await rl.question(q);
+        const v = ans.trim();
+        return v.length ? v : defaultValue;
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Prompt for selection from a list of choices
+ */
+async function promptSelect(label, choices, defaultValue) {
+    const rl = promises_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        // eslint-disable-next-line no-console
+        console.log(`${label}:\n`);
+        choices.forEach((choice, index) => {
+            const marker = defaultValue === choice.value ? " (default)" : "";
+            // eslint-disable-next-line no-console
+            console.log(`  ${index + 1}. ${choice.label}${marker}`);
+        });
+        // eslint-disable-next-line no-console
+        console.log("");
+        const ans = await rl.question("Nummer wählen: ");
+        const num = parseInt(ans.trim(), 10);
+        if (num >= 1 && num <= choices.length) {
+            const choice = choices[num - 1];
+            if (choice)
+                return choice.value;
+        }
+        // If user typed the value directly
+        const found = choices.find((c) => c.value.toLowerCase() === ans.trim().toLowerCase());
+        if (found) {
+            return found.value;
+        }
+        // Return default or first choice
+        if (defaultValue)
+            return defaultValue;
+        const first = choices[0];
+        return first ? first.value : "";
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Prompt for yes/no confirmation
+ */
+async function promptConfirm(label, defaultYes = false) {
+    const rl = promises_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const hint = defaultYes ? "(J/n)" : "(j/N)";
+        const ans = await rl.question(`${label} ${hint}: `);
+        const v = ans.trim().toLowerCase();
+        if (v === "j" || v === "y" || v === "ja" || v === "yes")
+            return true;
+        if (v === "n" || v === "nein" || v === "no")
+            return false;
+        return defaultYes;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/lib/notifications.d.ts

@@ -0,0 +1,2 @@
+import type { NotificationMode } from "./types.js";
+export declare function notify(mode: NotificationMode, title: string, message: string): Promise<void>;

package/dist/lib/notifications.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notify = notify;
+const node_os_1 = __importDefault(require("node:os"));
+const exec_js_1 = require("./exec.js");
+async function notify(mode, title, message) {
+    if (mode === "terminal" || mode === "both") {
+        // eslint-disable-next-line no-console
+        console.log(`\n[PULSE] ${title}\n${message}\n`);
+    }
+    if (mode === "macos" || mode === "both") {
+        if (node_os_1.default.platform() !== "darwin")
+            return;
+        // macOS notification via osascript
+        const script = `display notification ${jsonString(message)} with title ${jsonString(title)}`;
+        await (0, exec_js_1.exec)("osascript", ["-e", script]);
+    }
+}
+function jsonString(s) {
+    // osascript expects quoted AppleScript strings; JSON string works as a safe quoted string
+    return JSON.stringify(s);
+}

package/dist/lib/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function findRepoRoot(startDir: string): Promise<string | null>;
+export declare function pulseDir(repoRoot: string): string;
+export declare function stateFile(repoRoot: string): string;
+export declare function configFile(repoRoot: string): string;

package/dist/lib/paths.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRepoRoot = findRepoRoot;
+exports.pulseDir = pulseDir;
+exports.stateFile = stateFile;
+exports.configFile = configFile;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+async function findRepoRoot(startDir) {
+    let cur = node_path_1.default.resolve(startDir);
+    for (let i = 0; i < 50; i++) {
+        const gitDir = node_path_1.default.join(cur, ".git");
+        try {
+            const st = await promises_1.default.stat(gitDir);
+            if (st.isDirectory())
+                return cur;
+        }
+        catch {
+            // ignore
+        }
+        const parent = node_path_1.default.dirname(cur);
+        if (parent === cur)
+            return null;
+        cur = parent;
+    }
+    return null;
+}
+function pulseDir(repoRoot) {
+    return node_path_1.default.join(repoRoot, ".pulse");
+}
+function stateFile(repoRoot) {
+    return node_path_1.default.join(pulseDir(repoRoot), "state.json");
+}
+function configFile(repoRoot) {
+    return node_path_1.default.join(repoRoot, "pulse.config.json");
+}

package/dist/lib/prompts.d.ts

@@ -0,0 +1,43 @@
+import type { PulseLayer } from "./types.js";
+export type SixElements = {
+    role?: string;
+    context?: string;
+    input?: string;
+    action?: string;
+    output?: string;
+    examples?: string;
+};
+/**
+ * Generates a 6-Element prompt exactly as specified in the PULSE Framework.
+ * This is the core template that should be copy-pasted into AI tools.
+ */
+export declare function renderSixElementPrompt(layer: PulseLayer, el: SixElements): string;
+export declare function renderIstSollPrompt(options: {
+    ist: string;
+    soll: string;
+    error?: string;
+    context?: string;
+}): string;
+export declare function renderEscalationPrompt(options: {
+    cursorExplanation: string;
+    errorText: string;
+    gitLog: string;
+    gitDiff: string;
+    question: string;
+    codeSnippets?: string;
+    attempts?: string[];
+}): string;
+export type PromptTemplate = {
+    id: string;
+    name: string;
+    description: string;
+    layer: PulseLayer;
+    defaults: Partial<SixElements>;
+};
+export declare const PROMPT_TEMPLATES: PromptTemplate[];
+export declare function countProvidedElements(el: SixElements): number;
+export declare function validateOneAction(action: string | undefined): string | null;
+/**
+ * Get template by ID
+ */
+export declare function getTemplateById(id: string): PromptTemplate | undefined;