@happy-nut/monacori 0.1.0 → 0.1.3

package/dist/types.d.ts

@@ -0,0 +1,99 @@
+export type FlowConfig = {
+    version: 1;
+    projectName: string;
+    verification: {
+        commands: string[];
+    };
+    diff: {
+        context: number;
+        includeUntracked: boolean;
+    };
+};
+export type GitSnapshot = {
+    branch: string;
+    status: string;
+    diffStat: string;
+    recentCommits: string;
+};
+export type DiffLine = {
+    kind: "context" | "add" | "delete";
+    oldLine?: number;
+    newLine?: number;
+    text: string;
+};
+export type DiffHunk = {
+    header: string;
+    title: string;
+    oldStart: number;
+    newStart: number;
+    lines: DiffLine[];
+};
+export type DiffFile = {
+    oldPath: string;
+    newPath: string;
+    displayPath: string;
+    status: string;
+    binary: boolean;
+    hunks: DiffHunk[];
+    vcs?: "new" | "edited" | "staged";
+};
+export type SourceFile = {
+    path: string;
+    name: string;
+    language: string;
+    content: string;
+    size: number;
+    changed: boolean;
+    embedded: boolean;
+    changedLines: number[];
+    signature: string;
+    skippedReason?: string;
+    image?: string;
+    vcs?: "new" | "edited" | "staged";
+};
+export type HttpSendRequest = {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: string;
+};
+export type HttpSendResult = {
+    ok: boolean;
+    status?: number;
+    statusText?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    error?: string;
+    durationMs: number;
+};
+export type SourceTreeNode = {
+    name: string;
+    path: string;
+    children: Map<string, SourceTreeNode>;
+    file?: SourceFile;
+};
+export type DiffReviewResult = {
+    path: string;
+    url: string;
+    files: number;
+    hunks: number;
+};
+export type DiffReviewBuild = {
+    html: string;
+    files: number;
+    hunks: number;
+    signature: string;
+    generatedAt: string;
+    lazyBodies?: string[];
+    lazySourceData?: string;
+};
+export type VerificationRun = {
+    commands: string[];
+    failed: boolean;
+    skipped: boolean;
+    logPath?: string;
+};
+export type ReviewFileState = {
+    path: string;
+    signature: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/util.d.ts

@@ -0,0 +1,18 @@
+export declare function stripHtmlTags(value: string): string;
+export declare function decodeEntities(value: string): string;
+export declare function stripDiffPath(value: string): string;
+export declare function languageForPath(path: string): string;
+export declare function isLikelyBinary(path: string): boolean;
+export declare function readOption(args: string[], name: string): string | undefined;
+export declare function parsePositiveInteger(value: string, optionName: string): number;
+export declare function readStdin(): string;
+export declare function summarizeForState(content: string): string;
+export declare function codeBlock(content: string): string;
+export declare function timestampForFile(): string;
+export declare function hashText(value: string): string;
+export declare function sanitizeFilePart(value: string): string;
+export declare function escapeHtml(value: string): string;
+export declare function jsonForScript(value: unknown): string;
+export declare function escapeAttr(value: string): string;
+export declare function formatBytes(bytes: number): string;
+export declare function listRecentFiles(dir: string, limit: number): string[];

package/dist/util.js

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+export function stripHtmlTags(value) {
+    return value.replace(/<[^>]*>/g, "");
+}
+export function decodeEntities(value) {
+    return value
+        .replace(/&#x([0-9a-fA-F]+);/g, (_match, hex) => String.fromCodePoint(parseInt(hex, 16)))
+        .replace(/&#(\d+);/g, (_match, dec) => String.fromCodePoint(parseInt(dec, 10)))
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, "\"")
+        .replace(/&amp;/g, "&");
+}
+export function stripDiffPath(value) {
+    if (value === "/dev/null") {
+        return value;
+    }
+    return value.replace(/^[ab]\//, "");
+}
+export function languageForPath(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".ts") || lower.endsWith(".tsx"))
+        return "typescript";
+    if (lower.endsWith(".js") || lower.endsWith(".jsx") || lower.endsWith(".mjs") || lower.endsWith(".cjs"))
+        return "javascript";
+    if (lower.endsWith(".json"))
+        return "json";
+    if (lower.endsWith(".css") || lower.endsWith(".scss") || lower.endsWith(".sass"))
+        return "css";
+    if (lower.endsWith(".html") || lower.endsWith(".htm") || lower.endsWith(".xml") || lower.endsWith(".svg"))
+        return "markup";
+    if (lower.endsWith(".md") || lower.endsWith(".mdx"))
+        return "markdown";
+    if (lower.endsWith(".py"))
+        return "python";
+    if (lower.endsWith(".rb"))
+        return "ruby";
+    if (lower.endsWith(".go"))
+        return "go";
+    if (lower.endsWith(".rs"))
+        return "rust";
+    if (lower.endsWith(".java") || lower.endsWith(".kt") || lower.endsWith(".kts"))
+        return "java";
+    if (lower.endsWith(".sh") || lower.endsWith(".bash") || lower.endsWith(".zsh"))
+        return "shell";
+    if (lower.endsWith(".yml") || lower.endsWith(".yaml"))
+        return "yaml";
+    if (lower.endsWith(".toml"))
+        return "toml";
+    if (lower.endsWith(".sql"))
+        return "sql";
+    if (lower.endsWith(".http") || lower.endsWith(".rest"))
+        return "http";
+    return "text";
+}
+export function isLikelyBinary(path) {
+    const sample = readFileSync(path).subarray(0, 8000);
+    return sample.includes(0);
+}
+export function readOption(args, name) {
+    const index = args.indexOf(name);
+    if (index < 0) {
+        return undefined;
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+        throw new Error(`Missing value for ${name}`);
+    }
+    return value;
+}
+export function parsePositiveInteger(value, optionName) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`${optionName} must be a non-negative integer`);
+    }
+    return parsed;
+}
+export function readStdin() {
+    if (process.stdin.isTTY) {
+        return "";
+    }
+    return readFileSync(0, "utf8");
+}
+export function summarizeForState(content) {
+    const lines = content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .slice(0, 12);
+    return lines.map((line) => `- ${line.replace(/^-+\s*/, "")}`).join("\n");
+}
+export function codeBlock(content) {
+    return ["```", content, "```"].join("\n");
+}
+export function timestampForFile() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}
+export function hashText(value) {
+    return createHash("sha1").update(value).digest("hex");
+}
+export function sanitizeFilePart(value) {
+    return value.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-|-$/g, "");
+}
+export function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+export function jsonForScript(value) {
+    return JSON.stringify(value)
+        .replace(/</g, "\\u003c")
+        .replace(/>/g, "\\u003e")
+        .replace(/&/g, "\\u0026")
+        .replace(/\u2028/g, "\\u2028")
+        .replace(/\u2029/g, "\\u2029");
+}
+export function escapeAttr(value) {
+    return escapeHtml(value);
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    const kib = bytes / 1024;
+    if (kib < 1024) {
+        return `${kib.toFixed(1)} KiB`;
+    }
+    return `${(kib / 1024).toFixed(1)} MiB`;
+}
+export function listRecentFiles(dir, limit) {
+    if (!existsSync(dir)) {
+        return [];
+    }
+    return readdirSync(dir)
+        .map((name) => join(dir, name))
+        .filter((path) => statSync(path).isFile())
+        .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)
+        .slice(0, limit);
+}