@abelfubu/dv 0.1.0

package/dist/dropdown.js

@@ -0,0 +1,172 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentuah/react/jsx-runtime";
+// Searchable dropdown component for file and theme selection in TUI.
+// Supports keyboard navigation, fuzzy search filtering, and mouse interaction.
+// Used by main diff view for file picker and theme picker overlays.
+import React, { useCallback, useEffect, useRef, useState } from "react";
+import { useKeyboard } from "@opentuah/react";
+import { TextAttributes, TextareaRenderable } from "@opentuah/core";
+import { rgbaToHex } from "./themes";
+export function filterDropdownOptions(options, searchText) {
+    if (!searchText.trim()) {
+        return options;
+    }
+    const needles = searchText.toLowerCase().trim().split(/\s+/);
+    return options.filter((option) => {
+        const searchableText = [option.title, ...(option.keywords || [])]
+            .filter(Boolean)
+            .join(" ")
+            .toLowerCase();
+        return needles.every((needle) => searchableText.includes(needle));
+    });
+}
+const Dropdown = (props) => {
+    const { tooltip, onChange, onFocus, onEscape, selectedValues = [], options, placeholder = "Search…", itemsPerPage = 10, theme: resolvedTheme, } = props;
+    // Convert RGBA theme colors to hex for use in components
+    const theme = {
+        primary: rgbaToHex(resolvedTheme.primary),
+        background: rgbaToHex(resolvedTheme.background),
+        backgroundPanel: rgbaToHex(resolvedTheme.backgroundPanel),
+        text: rgbaToHex(resolvedTheme.text),
+        textMuted: rgbaToHex(resolvedTheme.textMuted),
+    };
+    const [selected, setSelected] = useState(0);
+    const [offset, setOffset] = useState(0);
+    const [searchText, setSearchText] = useState("");
+    const textareaRef = useRef(null);
+    const setTextareaRef = useCallback((node) => {
+        textareaRef.current = node;
+    }, []);
+    const syncSearchFromTextarea = useCallback(() => {
+        queueMicrotask(() => {
+            const nextText = textareaRef.current?.plainText ?? "";
+            setSearchText(nextText);
+        });
+    }, []);
+    const inFocus = true;
+    // Filter options based on search
+    const filteredOptions = filterDropdownOptions(options, searchText);
+    // Get visible options for current page
+    const visibleOptions = filteredOptions.slice(offset, offset + itemsPerPage);
+    // Reset selected index and offset when search changes
+    useEffect(() => {
+        setSelected(0);
+        setOffset(0);
+        // Call onFocus for the first filtered item
+        const firstOption = filteredOptions[0];
+        if (firstOption && onFocus) {
+            onFocus(firstOption.value);
+        }
+    }, [searchText, filteredOptions.length]);
+    const move = (direction) => {
+        const itemCount = filteredOptions.length;
+        if (itemCount === 0)
+            return;
+        if (direction === 1) {
+            setSelected((prev) => {
+                const nextIndex = (prev + 1) % itemCount;
+                const visibleEnd = offset + itemsPerPage - 1;
+                if (prev === visibleEnd && nextIndex < itemCount && nextIndex > prev) {
+                    setOffset(offset + 1);
+                }
+                else if (nextIndex < prev) {
+                    setOffset(0);
+                }
+                // Call onFocus with the newly focused item
+                const focusedOption = filteredOptions[nextIndex];
+                if (focusedOption && onFocus) {
+                    onFocus(focusedOption.value);
+                }
+                return nextIndex;
+            });
+        }
+        else {
+            setSelected((prev) => {
+                const nextIndex = (prev - 1 + itemCount) % itemCount;
+                if (nextIndex < offset) {
+                    setOffset(Math.max(0, nextIndex));
+                }
+                else if (nextIndex >= offset + itemsPerPage) {
+                    setOffset(Math.max(0, itemCount - itemsPerPage));
+                }
+                // Call onFocus with the newly focused item
+                const focusedOption = filteredOptions[nextIndex];
+                if (focusedOption && onFocus) {
+                    onFocus(focusedOption.value);
+                }
+                return nextIndex;
+            });
+        }
+    };
+    const selectItem = (itemValue) => {
+        if (onChange) {
+            onChange(itemValue);
+        }
+    };
+    // Handle keyboard navigation
+    useKeyboard((evt) => {
+        if (evt.name === "escape") {
+            evt.stopPropagation();
+            if (onEscape) {
+                onEscape();
+            }
+            return;
+        }
+        if (evt.name === "up") {
+            move(-1);
+        }
+        if (evt.name === "down") {
+            move(1);
+        }
+        if (evt.name === "return") {
+            const currentOption = filteredOptions[selected];
+            if (currentOption) {
+                selectItem(currentOption.value);
+            }
+            return;
+        }
+    });
+    return (_jsxs("box", { children: [_jsxs("box", { style: { paddingLeft: 2, paddingRight: 2 }, children: [_jsxs("box", { style: { paddingLeft: 1, paddingRight: 1 }, children: [_jsxs("box", { style: {
+                                    flexDirection: "row",
+                                    justifyContent: "space-between",
+                                }, children: [_jsx("text", { attributes: TextAttributes.BOLD, children: tooltip }), _jsx("text", { fg: theme.textMuted, children: "esc" })] }), _jsxs("box", { style: { paddingTop: 1, paddingBottom: 1, flexDirection: "row" }, children: [_jsx("text", { flexShrink: 0, fg: theme.primary, children: "> " }), _jsx("textarea", { ref: setTextareaRef, height: 1, flexGrow: 1, wrapMode: "none", onContentChange: syncSearchFromTextarea, placeholder: placeholder, focused: inFocus, focusedBackgroundColor: theme.backgroundPanel, cursorColor: theme.primary, focusedTextColor: theme.textMuted })] })] }), _jsx("box", { style: { paddingBottom: 1 }, children: visibleOptions.map((option, idx) => {
+                            const globalIndex = offset + idx;
+                            const isActive = globalIndex === selected;
+                            const isCurrent = selectedValues.includes(option.value);
+                            return (_jsx("box", { children: _jsx(ItemOption, { title: option.title, icon: option.icon, active: isActive, current: isCurrent, label: option.label, theme: theme, onMouseMove: () => {
+                                        setSelected(globalIndex);
+                                        if (onFocus)
+                                            onFocus(option.value);
+                                    }, onMouseDown: () => selectItem(option.value) }) }, option.value));
+                        }) })] }), _jsxs("box", { border: false, style: {
+                    paddingRight: 2,
+                    paddingLeft: 3,
+                    paddingBottom: 1,
+                    paddingTop: 1,
+                    flexDirection: "row",
+                }, children: [_jsx("text", { fg: theme.text, attributes: TextAttributes.BOLD, children: "\u21B5" }), _jsx("text", { fg: theme.textMuted, children: " select" }), _jsxs("text", { fg: theme.text, attributes: TextAttributes.BOLD, children: ["   ", "\u2191\u2193"] }), _jsx("text", { fg: theme.textMuted, children: " navigate" })] })] }));
+};
+function ItemOption(props) {
+    const [isHovered, setIsHovered] = useState(false);
+    const { theme } = props;
+    return (_jsxs("box", { style: {
+            flexDirection: "row",
+            backgroundColor: props.active
+                ? theme.primary
+                : isHovered
+                    ? theme.backgroundPanel
+                    : undefined,
+            paddingLeft: props.active ? 0 : 1,
+            paddingRight: 1,
+            justifyContent: "space-between",
+        }, border: false, onMouseMove: () => {
+            setIsHovered(true);
+            if (props.onMouseMove)
+                props.onMouseMove();
+        }, onMouseOut: () => setIsHovered(false), onMouseDown: props.onMouseDown, children: [_jsxs("box", { style: { flexDirection: "row" }, children: [props.active && (_jsxs("text", { fg: theme.background, selectable: false, children: ["\u203A", ""] })), props.icon && (_jsxs("text", { fg: props.active ? theme.background : theme.text, selectable: false, children: [String(props.icon), " "] })), _jsx("text", { fg: props.active
+                            ? theme.background
+                            : props.current
+                                ? theme.primary
+                                : theme.text, attributes: props.active ? TextAttributes.BOLD : undefined, selectable: false, children: props.title })] }), props.label && (_jsx("text", { fg: props.active ? theme.background : theme.textMuted, attributes: props.active ? TextAttributes.BOLD : undefined, selectable: false, children: props.label }))] }));
+}
+export default Dropdown;
+export { Dropdown };

package/dist/dropdown.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dropdown.test.d.ts.map

package/dist/dropdown.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropdown.test.d.ts","sourceRoot":"","sources":["../src/dropdown.test.tsx"],"names":[],"mappings":""}

package/dist/dropdown.test.js

@@ -0,0 +1,106 @@
+import { jsx as _jsx } from "@opentuah/react/jsx-runtime";
+import * as React from "react";
+import { afterEach, describe, expect, it } from "bun:test";
+import { act } from "react";
+import { testRender } from "@opentuah/react/test-utils";
+import Dropdown, { filterDropdownOptions } from "./dropdown.js";
+import { getResolvedTheme } from "./themes.js";
+const themeOptions = [
+    { title: "GitHub", value: "github" },
+    { title: "Tokyo Night", value: "tokyonight" },
+];
+function DropdownHarness() {
+    const [open, setOpen] = React.useState(true);
+    const theme = getResolvedTheme("github");
+    if (!open) {
+        return _jsx("text", { children: "closed" });
+    }
+    return (_jsx(Dropdown, { tooltip: "Select theme", options: themeOptions, selectedValues: [], onEscape: () => setOpen(false), theme: theme }));
+}
+// Suppress React act() warnings for opentui input tests.
+// opentui's mockInput triggers state updates asynchronously via stdin parsing,
+// which inherently happens outside act(). This is expected behavior for TUI
+// component testing — not a real problem.
+// testRender sets IS_REACT_ACT_ENVIRONMENT=true, so we must disable it after.
+async function setupTest(jsx, opts) {
+    const setup = await testRender(jsx, opts);
+    globalThis.IS_REACT_ACT_ENVIRONMENT = false;
+    return setup;
+}
+describe("Dropdown", () => {
+    let testSetup;
+    afterEach(() => {
+        if (testSetup) {
+            testSetup.renderer.destroy();
+        }
+    });
+    it("closes on escape", async () => {
+        testSetup = await setupTest(_jsx(DropdownHarness, {}), {
+            width: 50,
+            height: 12,
+        });
+        await testSetup.renderOnce();
+        let frame = testSetup.captureCharFrame();
+        expect(frame).toContain("Select theme");
+        // Press escape - emits to stdin which triggers useKeyboard handler
+        testSetup.mockInput.pressEscape();
+        // Allow stdin event to be parsed and trigger React state update
+        await new Promise(r => setTimeout(r, 10));
+        // Render the updated state
+        await testSetup.renderOnce();
+        frame = testSetup.captureCharFrame();
+        expect(frame).toContain("closed");
+        expect(frame).not.toContain("Select theme");
+    });
+    it("filters visible options when typing in textarea", async () => {
+        testSetup = await setupTest(_jsx(DropdownHarness, {}), {
+            width: 50,
+            height: 12,
+        });
+        await testSetup.renderOnce();
+        let frame = testSetup.captureCharFrame();
+        // Both options visible initially
+        expect(frame).toContain("GitHub");
+        expect(frame).toContain("Tokyo Night");
+        // Type "tokyo" to filter — should hide GitHub and show only Tokyo Night
+        await testSetup.mockInput.typeText("tokyo");
+        await new Promise(r => setTimeout(r, 50));
+        await testSetup.renderOnce();
+        frame = testSetup.captureCharFrame();
+        expect(frame).toContain("Tokyo Night");
+        expect(frame).not.toContain("GitHub");
+    });
+    it("filters options by title and keyword intersections", () => {
+        const options = [
+            { title: "GitHub", value: "github", keywords: ["git", "hub"] },
+            { title: "Tokyo Night", value: "tokyonight", keywords: ["tokyo", "night"] },
+            { title: "Ayu", value: "ayu", keywords: ["light"] },
+        ];
+        const tokyoOnly = filterDropdownOptions(options, "tokyo");
+        expect(tokyoOnly).toMatchInlineSnapshot(`
+      [
+        {
+          "keywords": [
+            "tokyo",
+            "night",
+          ],
+          "title": "Tokyo Night",
+          "value": "tokyonight",
+        },
+      ]
+    `);
+        const intersection = filterDropdownOptions(options, "git hub");
+        expect(intersection).toMatchInlineSnapshot(`
+      [
+        {
+          "keywords": [
+            "git",
+            "hub",
+          ],
+          "title": "GitHub",
+          "value": "github",
+        },
+      ]
+    `);
+    });
+});

package/dist/filter-submodule.e2e.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=filter-submodule.e2e.test.d.ts.map

package/dist/filter-submodule.e2e.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-submodule.e2e.test.d.ts","sourceRoot":"","sources":["../src/filter-submodule.e2e.test.ts"],"names":[],"mappings":""}

package/dist/filter-submodule.e2e.test.js

@@ -0,0 +1,109 @@
+// End-to-end tests for --filter behavior when dirty submodule diffs are merged.
+// Uses real git repositories and real CLI invocations to mirror user workflows.
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import child_process from "child_process";
+import fs from "fs";
+import path from "path";
+import stripAnsi from "strip-ansi";
+const TEMP_ROOT = path.join(import.meta.dir, ".test-filter-submodule-e2e-tmp");
+const CLI_PATH = path.join(import.meta.dir, "cli.tsx");
+function runCommand(command, args, cwd) {
+    return child_process.execFileSync(command, args, {
+        cwd,
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            GIT_ALLOW_PROTOCOL: "file",
+        },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+}
+function runGit(cwd, args) {
+    return runCommand("git", args, cwd);
+}
+function configureGitIdentity(repoPath) {
+    runGit(repoPath, ["config", "user.name", "Critique Tests"]);
+    runGit(repoPath, ["config", "user.email", "tests@critique.local"]);
+}
+function writeFile(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+}
+function createFixtureRepo(testName) {
+    const slug = testName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    const fixtureRoot = fs.mkdtempSync(path.join(TEMP_ROOT, `${slug}-`));
+    const submoduleSource = path.join(fixtureRoot, "submodule-source");
+    const parentRepo = path.join(fixtureRoot, "parent-repo");
+    fs.mkdirSync(submoduleSource, { recursive: true });
+    runGit(submoduleSource, ["init"]);
+    configureGitIdentity(submoduleSource);
+    writeFile(path.join(submoduleSource, "packages/react/src/widget.ts"), [
+        "export const widget = 'submodule'",
+        "export const widgetVersion = 1",
+        "",
+    ].join("\n"));
+    runGit(submoduleSource, ["add", "."]);
+    runGit(submoduleSource, ["commit", "-m", "initial submodule commit"]);
+    fs.mkdirSync(parentRepo, { recursive: true });
+    runGit(parentRepo, ["init"]);
+    configureGitIdentity(parentRepo);
+    writeFile(path.join(parentRepo, "src/root.ts"), [
+        "export const rootFile = true",
+        "export const rootVersion = 1",
+        "",
+    ].join("\n"));
+    runGit(parentRepo, ["add", "."]);
+    runGit(parentRepo, ["commit", "-m", "initial parent commit"]);
+    runGit(parentRepo, [
+        "-c",
+        "protocol.file.allow=always",
+        "submodule",
+        "add",
+        submoduleSource,
+        "vendor/opentui",
+    ]);
+    runGit(parentRepo, ["add", "."]);
+    runGit(parentRepo, ["commit", "-m", "add submodule"]);
+    fs.appendFileSync(path.join(parentRepo, "src/root.ts"), "export const rootChanged = true\n");
+    fs.appendFileSync(path.join(parentRepo, "vendor/opentui/packages/react/src/widget.ts"), "export const submoduleChanged = true\n");
+    return parentRepo;
+}
+function runCritiqueWithFilters(repoPath, filters) {
+    const args = [CLI_PATH, "--scrollback", "--no-stdin"];
+    for (const filter of filters) {
+        args.push("--filter", filter);
+    }
+    const output = runCommand("bun", args, repoPath);
+    return stripAnsi(output).replace(/\r/g, "").trim();
+}
+describe("e2e: filter with dirty submodules", () => {
+    beforeAll(() => {
+        fs.mkdirSync(TEMP_ROOT, { recursive: true });
+    });
+    afterAll(() => {
+        fs.rmSync(TEMP_ROOT, { recursive: true, force: true });
+    });
+    test("user example: critique --scrollback --filter 'vendor/opentui/**'", () => {
+        const repoPath = createFixtureRepo("submodule-glob-filter");
+        const output = runCritiqueWithFilters(repoPath, ["vendor/opentui/**"]);
+        expect(output).toContain("vendor/opentui/packages/react/src/widget.ts");
+        expect(output).toContain("submoduleChanged");
+        expect(output).not.toContain("src/root.ts");
+        expect(output).not.toContain("unknown +0-0");
+    }, 120000);
+    test("user example: critique --scrollback --filter 'src'", () => {
+        const repoPath = createFixtureRepo("plain-path-filter");
+        const output = runCritiqueWithFilters(repoPath, ["src"]);
+        expect(output).toContain("src/root.ts");
+        expect(output).toContain("rootChanged");
+        expect(output).not.toContain("vendor/opentui/packages/react/src/widget.ts");
+        expect(output).not.toContain("unknown +0-0");
+    }, 120000);
+    test("user example: critique --scrollback --filter '.'", () => {
+        const repoPath = createFixtureRepo("dot-root-filter");
+        const output = runCritiqueWithFilters(repoPath, ["."]);
+        expect(output).toContain("src/root.ts");
+        expect(output).toContain("vendor/opentui/packages/react/src/widget.ts");
+        expect(output).not.toContain("unknown +0-0");
+    }, 120000);
+});

package/dist/hooks/use-copy-selection.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Props for the mouseup handler returned by useCopySelection
+ */
+export interface CopySelectionHandlers {
+    /** Attach this to the root box's onMouseUp prop */
+    onMouseUp: () => Promise<void>;
+}
+/**
+ * Hook that provides a mouseup handler for copy-on-selection behavior.
+ * When the user releases the mouse button after selecting text,
+ * the selected text is automatically copied to the clipboard.
+ *
+ * @returns Object with onMouseUp handler to attach to root component
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { onMouseUp } = useCopySelection()
+ *
+ *   return (
+ *     <box onMouseUp={onMouseUp}>
+ *       <text>Select this text and release to copy</text>
+ *     </box>
+ *   )
+ * }
+ * ```
+ */
+export declare function useCopySelection(): CopySelectionHandlers;
+//# sourceMappingURL=use-copy-selection.d.ts.map

package/dist/hooks/use-copy-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-copy-selection.d.ts","sourceRoot":"","sources":["../../src/hooks/use-copy-selection.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,mDAAmD;IACnD,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC/B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAqBxD"}

package/dist/hooks/use-copy-selection.js

@@ -0,0 +1,46 @@
+// Hook for copy-to-clipboard on mouse selection release.
+// Automatically copies selected text to clipboard when user releases mouse button.
+// Uses native clipboard commands (pbcopy, xclip, etc.) with OSC52 fallback.
+import { useRenderer } from "@opentuah/react";
+import { copyToClipboard } from "../clipboard.js";
+/**
+ * Hook that provides a mouseup handler for copy-on-selection behavior.
+ * When the user releases the mouse button after selecting text,
+ * the selected text is automatically copied to the clipboard.
+ *
+ * @returns Object with onMouseUp handler to attach to root component
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { onMouseUp } = useCopySelection()
+ *
+ *   return (
+ *     <box onMouseUp={onMouseUp}>
+ *       <text>Select this text and release to copy</text>
+ *     </box>
+ *   )
+ * }
+ * ```
+ */
+export function useCopySelection() {
+    const renderer = useRenderer();
+    const onMouseUp = async () => {
+        const selection = renderer.getSelection();
+        if (!selection)
+            return;
+        if (selection.isDragging)
+            return;
+        const text = selection.getSelectedText();
+        if (!text || text.length === 0)
+            return;
+        try {
+            await copyToClipboard(text, (value) => renderer.copyToClipboardOSC52(value));
+        }
+        catch {
+            // Silent fail - user can manually copy if needed
+        }
+        renderer.clearSelection();
+    };
+    return { onMouseUp };
+}

package/dist/kv-codec.d.ts

@@ -0,0 +1,16 @@
+export type KvValueMetadata = {
+    contentType?: string;
+    contentEncoding?: "gzip";
+    schemaVersion?: 1;
+};
+export declare const KV_SCHEMA_VERSION: 1;
+export declare function buildKvPutOptions(ttlSeconds?: number, metadata?: KvValueMetadata): {
+    expirationTtl?: number;
+    metadata?: KvValueMetadata;
+} | undefined;
+export declare function gzipArrayBuffer(buffer: ArrayBuffer): Promise<ArrayBuffer>;
+export declare function gunzipArrayBuffer(buffer: ArrayBuffer): Promise<ArrayBuffer>;
+export declare function gzipText(value: string): Promise<ArrayBuffer>;
+export declare function decodeTextFromKv(value: ArrayBuffer, metadata: KvValueMetadata | null): Promise<string>;
+export declare function decodeBinaryFromKv(value: ArrayBuffer, metadata: KvValueMetadata | null): Promise<ArrayBuffer>;
+//# sourceMappingURL=kv-codec.d.ts.map

package/dist/kv-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kv-codec.d.ts","sourceRoot":"","sources":["../src/kv-codec.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,aAAa,CAAC,EAAE,CAAC,CAAA;CAClB,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAG,CAAU,CAAA;AAE3C,wBAAgB,iBAAiB,CAC/B,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,eAAe,GACzB;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,eAAe,CAAA;CAAE,GAAG,SAAS,CASpE;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAG/E;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAGjF;AAED,wBAAsB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAGlE;AAED,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,eAAe,GAAG,IAAI,GAC/B,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,eAAe,GAAG,IAAI,GAC/B,OAAO,CAAC,WAAW,CAAC,CAKtB"}

package/dist/kv-codec.js

@@ -0,0 +1,36 @@
+// KV value compression/decompression helpers for Cloudflare Worker storage.
+// Provides metadata-aware gzip encoding and decoding for text and binary payloads.
+export const KV_SCHEMA_VERSION = 1;
+export function buildKvPutOptions(ttlSeconds, metadata) {
+    if (ttlSeconds === undefined && metadata === undefined) {
+        return undefined;
+    }
+    return {
+        ...(ttlSeconds !== undefined ? { expirationTtl: ttlSeconds } : {}),
+        ...(metadata !== undefined ? { metadata } : {}),
+    };
+}
+export async function gzipArrayBuffer(buffer) {
+    const stream = new Blob([buffer]).stream().pipeThrough(new CompressionStream("gzip"));
+    return await new Response(stream).arrayBuffer();
+}
+export async function gunzipArrayBuffer(buffer) {
+    const stream = new Blob([buffer]).stream().pipeThrough(new DecompressionStream("gzip"));
+    return await new Response(stream).arrayBuffer();
+}
+export async function gzipText(value) {
+    const bytes = new TextEncoder().encode(value);
+    return gzipArrayBuffer(bytes.buffer);
+}
+export async function decodeTextFromKv(value, metadata) {
+    const buffer = metadata?.contentEncoding === "gzip"
+        ? await gunzipArrayBuffer(value)
+        : value;
+    return new TextDecoder().decode(buffer);
+}
+export async function decodeBinaryFromKv(value, metadata) {
+    if (metadata?.contentEncoding === "gzip") {
+        return await gunzipArrayBuffer(value);
+    }
+    return value;
+}

package/dist/license.d.ts

@@ -0,0 +1,14 @@
+export interface StoredLicense {
+    key?: string;
+    ownerSecret?: string;
+}
+export declare function loadStoredLicense(): StoredLicense | null;
+export declare function saveStoredLicense(license: StoredLicense): void;
+export declare function loadStoredLicenseKey(): string | null;
+export declare function saveStoredLicenseKey(key: string): void;
+/**
+ * Load existing owner secret or create one if it doesn't exist.
+ * The owner secret is used to authenticate diff deletion requests.
+ */
+export declare function loadOrCreateOwnerSecret(): string;
+//# sourceMappingURL=license.d.ts.map

package/dist/license.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"license.d.ts","sourceRoot":"","sources":["../src/license.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,wBAAgB,iBAAiB,IAAI,aAAa,GAAG,IAAI,CAOxD;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAS9D;AAED,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,IAAI,CAIpD;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAUtD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAiBhD"}

package/dist/license.js

@@ -0,0 +1,63 @@
+// License key storage in ~/.critique/license.json.
+// Also stores owner secret for authenticating diff deletion.
+import fs from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+const LICENSE_DIR = join(homedir(), ".critique");
+const LICENSE_FILE = join(LICENSE_DIR, "license.json");
+export function loadStoredLicense() {
+    try {
+        const data = fs.readFileSync(LICENSE_FILE, "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveStoredLicense(license) {
+    try {
+        if (!fs.existsSync(LICENSE_DIR)) {
+            fs.mkdirSync(LICENSE_DIR, { recursive: true });
+        }
+        fs.writeFileSync(LICENSE_FILE, JSON.stringify(license, null, 2));
+    }
+    catch {
+        // Ignore write errors
+    }
+}
+export function loadStoredLicenseKey() {
+    const license = loadStoredLicense();
+    if (!license?.key)
+        return null;
+    return license.key.trim() || null;
+}
+export function saveStoredLicenseKey(key) {
+    const trimmed = key.trim();
+    if (!trimmed)
+        return;
+    // Preserve existing owner secret when saving license key
+    const existing = loadStoredLicense();
+    saveStoredLicense({
+        ...existing,
+        key: trimmed,
+    });
+}
+/**
+ * Load existing owner secret or create one if it doesn't exist.
+ * The owner secret is used to authenticate diff deletion requests.
+ */
+export function loadOrCreateOwnerSecret() {
+    const existing = loadStoredLicense();
+    if (existing?.ownerSecret) {
+        return existing.ownerSecret;
+    }
+    // Generate new owner secret
+    const ownerSecret = randomUUID();
+    // Save while preserving existing license key
+    saveStoredLicense({
+        ...existing,
+        ownerSecret,
+    });
+    return ownerSecret;
+}

package/dist/logger.d.ts

@@ -0,0 +1,9 @@
+export declare const logger: {
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+};
+export default logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AA8CA,eAAO,MAAM,MAAM;iBACJ,OAAO,EAAE;kBAOR,OAAO,EAAE;kBAOT,OAAO,EAAE;mBAOR,OAAO,EAAE;mBAQT,OAAO,EAAE;CAMzB,CAAA;AAED,eAAe,MAAM,CAAA"}