@sheepbun/yips 0.1.1

package/dist/config/config.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_PATH_ENV_VAR = exports.DEFAULT_CONFIG_PATH = void 0;
+exports.getDefaultConfig = getDefaultConfig;
+exports.resolveConfigPath = resolveConfigPath;
+exports.mergeConfig = mergeConfig;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.updateConfig = updateConfig;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const SUPPORTED_BACKENDS = new Set(["llamacpp", "claude"]);
+const PORT_CONFLICT_POLICIES = new Set([
+    "fail",
+    "kill-llama",
+    "kill-user"
+]);
+const SUPPORTED_HOOKS = [
+    "on-session-start",
+    "on-session-end",
+    "on-file-write",
+    "on-file-read",
+    "pre-commit"
+];
+const DEFAULT_HOOK_TIMEOUT_MS = 10_000;
+const MAX_HOOK_TIMEOUT_MS = 120_000;
+exports.DEFAULT_CONFIG_PATH = ".yips_config.json";
+exports.CONFIG_PATH_ENV_VAR = "YIPS_CONFIG_PATH";
+function getDefaultConfig() {
+    const llamaHost = "127.0.0.1";
+    const llamaPort = 8080;
+    return {
+        streaming: true,
+        verbose: false,
+        backend: "llamacpp",
+        llamaBaseUrl: buildBaseUrl(llamaHost, llamaPort),
+        llamaServerPath: "",
+        llamaModelsDir: (0, node_path_1.resolve)((0, node_os_1.homedir)(), ".yips", "models"),
+        llamaHost,
+        llamaPort,
+        llamaContextSize: 8192,
+        llamaGpuLayers: 999,
+        llamaAutoStart: true,
+        llamaPortConflictPolicy: "kill-user",
+        model: "default",
+        tokensMode: "auto",
+        tokensManualMax: 8192,
+        nicknames: {},
+        hooks: {}
+    };
+}
+function resolveConfigPath(configPath = exports.DEFAULT_CONFIG_PATH) {
+    if (configPath === exports.DEFAULT_CONFIG_PATH) {
+        const envPath = process.env[exports.CONFIG_PATH_ENV_VAR]?.trim();
+        if (envPath && envPath.length > 0) {
+            return (0, node_path_1.resolve)(envPath);
+        }
+    }
+    return (0, node_path_1.resolve)(process.cwd(), configPath);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function normalizeBoolean(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function normalizeBackend(value, fallback) {
+    if (typeof value === "string" && SUPPORTED_BACKENDS.has(value)) {
+        return value;
+    }
+    return fallback;
+}
+function normalizeModel(value, fallback) {
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : fallback;
+}
+function normalizeBaseUrl(value, fallback) {
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return fallback;
+    }
+    try {
+        const parsed = new URL(trimmed);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            return fallback;
+        }
+        return parsed.toString().replace(/\/$/, "");
+    }
+    catch {
+        return fallback;
+    }
+}
+function parseBoolean(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on") {
+        return true;
+    }
+    if (normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off") {
+        return false;
+    }
+    return fallback;
+}
+function normalizeString(value, fallback) {
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : fallback;
+}
+function normalizeHost(value, fallback) {
+    return normalizeString(value, fallback);
+}
+function normalizePort(value, fallback) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 65535) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value.trim());
+        if (Number.isInteger(parsed) && parsed > 0 && parsed <= 65535) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
+function normalizePositiveInt(value, fallback) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value.trim());
+        if (Number.isInteger(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
+function normalizePositiveIntWithMax(value, fallback, max) {
+    const normalized = normalizePositiveInt(value, fallback);
+    return Math.min(normalized, max);
+}
+function normalizePortConflictPolicy(value, fallback) {
+    if (typeof value === "string" && PORT_CONFLICT_POLICIES.has(value)) {
+        return value;
+    }
+    return fallback;
+}
+function normalizeTokensMode(value, fallback) {
+    if (value === "auto" || value === "manual") {
+        return value;
+    }
+    return fallback;
+}
+function buildBaseUrl(host, port) {
+    return `http://${host}:${port}`;
+}
+function parseBaseUrlHostPort(baseUrl) {
+    try {
+        const parsed = new URL(baseUrl);
+        if (!parsed.hostname || !parsed.port) {
+            return null;
+        }
+        const port = Number(parsed.port);
+        if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+            return null;
+        }
+        return {
+            host: parsed.hostname,
+            port
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeNicknames(value, fallback) {
+    if (!isRecord(value)) {
+        return { ...fallback };
+    }
+    const next = {};
+    for (const [key, nickname] of Object.entries(value)) {
+        if (typeof key !== "string" || typeof nickname !== "string") {
+            continue;
+        }
+        const trimmedKey = key.trim();
+        const trimmedNickname = nickname.trim();
+        if (trimmedKey.length === 0 || trimmedNickname.length === 0) {
+            continue;
+        }
+        next[trimmedKey] = trimmedNickname;
+    }
+    return next;
+}
+function normalizeHookConfig(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const command = normalizeString(value.command, "");
+    if (command.length === 0) {
+        return null;
+    }
+    const timeoutMs = normalizePositiveIntWithMax(value.timeoutMs, DEFAULT_HOOK_TIMEOUT_MS, MAX_HOOK_TIMEOUT_MS);
+    return { command, timeoutMs };
+}
+function normalizeHooks(value, fallback) {
+    const next = {};
+    for (const hookName of SUPPORTED_HOOKS) {
+        const existing = fallback[hookName];
+        if (existing) {
+            next[hookName] = { ...existing };
+        }
+    }
+    if (!isRecord(value)) {
+        return next;
+    }
+    for (const hookName of SUPPORTED_HOOKS) {
+        const normalized = normalizeHookConfig(value[hookName]);
+        if (normalized) {
+            next[hookName] = normalized;
+        }
+    }
+    return next;
+}
+function applyEnvOverrides(config) {
+    const envHost = normalizeHost(process.env["YIPS_LLAMA_HOST"], config.llamaHost);
+    const envPort = normalizePort(process.env["YIPS_LLAMA_PORT"], config.llamaPort);
+    const envBaseUrl = normalizeBaseUrl(process.env["YIPS_LLAMA_BASE_URL"], buildBaseUrl(envHost, envPort));
+    const envBaseUrlHostPort = parseBaseUrlHostPort(envBaseUrl);
+    return {
+        ...config,
+        llamaHost: envBaseUrlHostPort?.host ?? envHost,
+        llamaPort: envBaseUrlHostPort?.port ?? envPort,
+        llamaBaseUrl: envBaseUrl,
+        llamaServerPath: normalizeString(process.env["YIPS_LLAMA_SERVER_PATH"], config.llamaServerPath),
+        llamaModelsDir: normalizeString(process.env["YIPS_LLAMA_MODELS_DIR"], config.llamaModelsDir),
+        llamaContextSize: normalizePositiveInt(process.env["YIPS_LLAMA_CONTEXT_SIZE"], config.llamaContextSize),
+        llamaGpuLayers: normalizePositiveInt(process.env["YIPS_LLAMA_GPU_LAYERS"], config.llamaGpuLayers),
+        llamaAutoStart: parseBoolean(process.env["YIPS_LLAMA_AUTO_START"], config.llamaAutoStart),
+        llamaPortConflictPolicy: normalizePortConflictPolicy(process.env["YIPS_LLAMA_PORT_CONFLICT_POLICY"], config.llamaPortConflictPolicy),
+        model: normalizeModel(process.env["YIPS_MODEL"], config.model),
+        tokensMode: normalizeTokensMode(process.env["YIPS_TOKENS_MODE"], config.tokensMode),
+        tokensManualMax: normalizePositiveInt(process.env["YIPS_TOKENS_MANUAL_MAX"], config.tokensManualMax),
+        hooks: normalizeHooks(config.hooks, config.hooks)
+    };
+}
+function mergeConfig(defaults, candidate) {
+    if (!isRecord(candidate)) {
+        return defaults;
+    }
+    const llamaHost = normalizeHost(candidate.llamaHost, defaults.llamaHost);
+    const llamaPort = normalizePort(candidate.llamaPort, defaults.llamaPort);
+    const llamaBaseUrl = normalizeBaseUrl(candidate.llamaBaseUrl, buildBaseUrl(llamaHost, llamaPort));
+    const baseUrlHostPort = parseBaseUrlHostPort(llamaBaseUrl);
+    return {
+        streaming: normalizeBoolean(candidate.streaming, defaults.streaming),
+        verbose: normalizeBoolean(candidate.verbose, defaults.verbose),
+        backend: normalizeBackend(candidate.backend, defaults.backend),
+        llamaBaseUrl,
+        llamaServerPath: normalizeString(candidate.llamaServerPath, defaults.llamaServerPath),
+        llamaModelsDir: normalizeString(candidate.llamaModelsDir, defaults.llamaModelsDir),
+        llamaHost: baseUrlHostPort?.host ?? llamaHost,
+        llamaPort: baseUrlHostPort?.port ?? llamaPort,
+        llamaContextSize: normalizePositiveInt(candidate.llamaContextSize, defaults.llamaContextSize),
+        llamaGpuLayers: normalizePositiveInt(candidate.llamaGpuLayers, defaults.llamaGpuLayers),
+        llamaAutoStart: normalizeBoolean(candidate.llamaAutoStart, defaults.llamaAutoStart),
+        llamaPortConflictPolicy: normalizePortConflictPolicy(candidate.llamaPortConflictPolicy, defaults.llamaPortConflictPolicy),
+        model: normalizeModel(candidate.model, defaults.model),
+        tokensMode: normalizeTokensMode(candidate.tokensMode, defaults.tokensMode),
+        tokensManualMax: normalizePositiveInt(candidate.tokensManualMax, defaults.tokensManualMax),
+        nicknames: normalizeNicknames(candidate.nicknames, defaults.nicknames),
+        hooks: normalizeHooks(candidate.hooks, defaults.hooks)
+    };
+}
+async function loadConfig(configPath = exports.DEFAULT_CONFIG_PATH) {
+    const defaults = getDefaultConfig();
+    const path = resolveConfigPath(configPath);
+    const legacyDefaultPath = (0, node_path_1.resolve)(process.cwd(), exports.DEFAULT_CONFIG_PATH);
+    const candidatePaths = [path];
+    if (configPath === exports.DEFAULT_CONFIG_PATH && path !== legacyDefaultPath) {
+        candidatePaths.push(legacyDefaultPath);
+    }
+    let readablePath = null;
+    for (const candidatePath of candidatePaths) {
+        try {
+            await (0, promises_1.access)(candidatePath, node_fs_1.constants.R_OK);
+            readablePath = candidatePath;
+            break;
+        }
+        catch {
+            // keep trying
+        }
+    }
+    if (!readablePath) {
+        return { config: applyEnvOverrides(defaults), path, source: "default" };
+    }
+    try {
+        const rawConfig = await (0, promises_1.readFile)(readablePath, "utf8");
+        const parsedConfig = JSON.parse(rawConfig);
+        return {
+            config: applyEnvOverrides(mergeConfig(defaults, parsedConfig)),
+            path: readablePath,
+            source: "file"
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            config: applyEnvOverrides(defaults),
+            path: readablePath,
+            source: "default",
+            warning: `Failed to load config at ${readablePath}: ${message}`
+        };
+    }
+}
+async function saveConfig(config, configPath = exports.DEFAULT_CONFIG_PATH) {
+    const path = resolveConfigPath(configPath);
+    const normalized = mergeConfig(getDefaultConfig(), config);
+    await (0, promises_1.writeFile)(path, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+}
+async function updateConfig(patch, configPath = exports.DEFAULT_CONFIG_PATH) {
+    const loaded = await loadConfig(configPath);
+    const merged = mergeConfig(getDefaultConfig(), { ...loaded.config, ...patch });
+    await saveConfig(merged, configPath);
+    return merged;
+}

package/dist/config/hooks.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHookFailure = formatHookFailure;
+exports.runHook = runHook;
+const node_child_process_1 = require("node:child_process");
+const DEFAULT_TIMEOUT_MS = 10_000;
+const MAX_TIMEOUT_MS = 120_000;
+const SHUTDOWN_GRACE_MS = 500;
+function resolveHookCommand(config, hook) {
+    const configured = config.hooks[hook]?.command;
+    if (typeof configured !== "string") {
+        return null;
+    }
+    const trimmed = configured.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function resolveHookTimeoutMs(config, hook) {
+    const configured = config.hooks[hook]?.timeoutMs;
+    if (typeof configured !== "number" || !Number.isInteger(configured) || configured <= 0) {
+        return DEFAULT_TIMEOUT_MS;
+    }
+    return Math.min(configured, MAX_TIMEOUT_MS);
+}
+function createEventId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function extractFilePath(payload) {
+    const path = payload["path"];
+    if (typeof path === "string" && path.trim().length > 0) {
+        return path.trim();
+    }
+    const filePath = payload["filePath"];
+    if (typeof filePath === "string" && filePath.trim().length > 0) {
+        return filePath.trim();
+    }
+    return null;
+}
+function formatHookFailure(result) {
+    const base = `[hook:${result.hook}] ${result.message}`;
+    if (result.status === "timeout") {
+        return base;
+    }
+    if (result.exitCode !== null) {
+        return `${base} (exit ${result.exitCode})`;
+    }
+    return base;
+}
+async function runHook(config, hook, payload, context = {}) {
+    const cwd = context.cwd ?? process.cwd();
+    const eventId = createEventId();
+    const timestamp = new Date().toISOString();
+    const command = resolveHookCommand(config, hook);
+    if (!command) {
+        return {
+            hook,
+            status: "skipped",
+            command: null,
+            cwd,
+            message: `No hook configured for ${hook}.`,
+            durationMs: 0,
+            eventId,
+            timestamp,
+            stdout: "",
+            stderr: "",
+            exitCode: null,
+            signal: null,
+            timedOut: false
+        };
+    }
+    const timeoutMs = resolveHookTimeoutMs(config, hook);
+    const filePath = extractFilePath(payload);
+    const startedAt = Date.now();
+    const envelope = {
+        hook,
+        eventId,
+        timestamp,
+        cwd,
+        sessionName: context.sessionName ?? null,
+        data: payload
+    };
+    return await new Promise((resolveResult) => {
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        let timedOut = false;
+        let killTimer = null;
+        const child = (0, node_child_process_1.spawn)("sh", ["-lc", command], {
+            cwd,
+            env: {
+                ...process.env,
+                ...context.env,
+                YIPS_HOOK_NAME: hook,
+                YIPS_HOOK_EVENT_ID: eventId,
+                YIPS_HOOK_TIMESTAMP: timestamp,
+                YIPS_HOOK_CWD: cwd,
+                YIPS_HOOK_SESSION_NAME: context.sessionName ?? "",
+                YIPS_HOOK_FILE_PATH: filePath ?? ""
+            },
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        const settle = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (killTimer) {
+                clearTimeout(killTimer);
+            }
+            resolveResult({
+                hook,
+                eventId,
+                timestamp,
+                cwd,
+                ...result
+            });
+        };
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", (error) => {
+            settle({
+                status: "error",
+                command,
+                message: `Hook execution failed: ${toErrorMessage(error)}`,
+                durationMs: Math.max(0, Date.now() - startedAt),
+                stdout,
+                stderr,
+                exitCode: null,
+                signal: null,
+                timedOut
+            });
+        });
+        child.on("close", (code, signal) => {
+            if (timedOut) {
+                settle({
+                    status: "timeout",
+                    command,
+                    message: `Hook timed out after ${timeoutMs}ms.`,
+                    durationMs: Math.max(0, Date.now() - startedAt),
+                    stdout,
+                    stderr,
+                    exitCode: code,
+                    signal,
+                    timedOut: true
+                });
+                return;
+            }
+            const success = code === 0;
+            settle({
+                status: success ? "ok" : "error",
+                command,
+                message: success ? "Hook completed successfully." : "Hook exited with a non-zero status.",
+                durationMs: Math.max(0, Date.now() - startedAt),
+                stdout,
+                stderr,
+                exitCode: code,
+                signal,
+                timedOut: false
+            });
+        });
+        killTimer = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            timedOut = true;
+            child.kill("SIGTERM");
+            setTimeout(() => {
+                if (!settled) {
+                    child.kill("SIGKILL");
+                }
+            }, SHUTDOWN_GRACE_MS);
+        }, timeoutMs);
+        const stdinPayload = `${JSON.stringify(envelope)}\n`;
+        child.stdin.write(stdinPayload, "utf8", (error) => {
+            if (error) {
+                stderr += `stdin write failed: ${toErrorMessage(error)}\n`;
+            }
+            child.stdin.end();
+        });
+    });
+}