howtofixcli 0.7.8 → 0.7.10

package/dist/schema.js

@@ -1,214 +0,0 @@
-/**
- * A small JSON Schema validator, sufficient for the `schema` option of
- * `agent()` in a workflow script.
- *
- * Why not a library: `ajv` is not installed and the SDK does not export a
- * validator, so a dependency would have to be vendored into a repo whose rule is
- * not to re-vendor the SDK. The supported subset is the one the workflow spec names
- * for structured output — `type`, `properties`, `required`, `items`, `enum`,
- * `anyOf`/`oneOf`/`allOf`, `$defs`/`definitions`, `additionalProperties` — which
- * is small enough to implement honestly, and the failure messages matter more
- * than breadth here: they are fed back to the model as a repair turn.
- *
- * Validation is intentionally permissive about keywords it does not understand
- * (they are ignored rather than failing the value), because the contract is that
- * a reply validating against the authored schema is accepted.
- */
-const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function typeOf(value) {
-    if (value === null)
-        return "null";
-    if (Array.isArray(value))
-        return "array";
-    if (Number.isInteger(value))
-        return "integer";
-    return typeof value;
-}
-function matchesType(value, want) {
-    const actual = typeOf(value);
-    if (want === "number")
-        return actual === "number" || actual === "integer";
-    if (want === "integer")
-        return actual === "integer";
-    return actual === want;
-}
-/** Resolve a `$ref` against the document root (`#/$defs/name` or `#/definitions/name`). */
-function resolveRef(root, ref) {
-    if (typeof ref !== "string" || !ref.startsWith("#/"))
-        return undefined;
-    let node = root;
-    for (const rawPart of ref.slice(2).split("/")) {
-        const part = rawPart.replace(/~1/g, "/").replace(/~0/g, "~");
-        if (!isObject(node) && !Array.isArray(node))
-            return undefined;
-        node = node[part];
-    }
-    return isObject(node) ? node : undefined;
-}
-function validateNode(value, schema, root, path, issues) {
-    if (!isObject(schema))
-        return;
-    if (schema.$ref !== undefined) {
-        const target = resolveRef(root, schema.$ref);
-        if (target)
-            validateNode(value, target, root, path, issues);
-        return;
-    }
-    // Combinators. `allOf` must hold everywhere; `anyOf`/`oneOf` need a passing branch.
-    if (Array.isArray(schema.allOf)) {
-        for (const branch of schema.allOf)
-            validateNode(value, branch, root, path, issues);
-    }
-    for (const keyword of ["anyOf", "oneOf"]) {
-        const branches = schema[keyword];
-        if (!Array.isArray(branches) || branches.length === 0)
-            continue;
-        const passes = branches.filter((branch) => {
-            const scratch = [];
-            validateNode(value, branch, root, path, scratch);
-            return scratch.length === 0;
-        }).length;
-        if (keyword === "anyOf" && passes === 0)
-            issues.push({ path, message: "does not match any allowed shape" });
-        if (keyword === "oneOf" && passes !== 1)
-            issues.push({ path, message: `must match exactly one shape (matched ${passes})` });
-    }
-    const declaredType = schema.type;
-    if (declaredType !== undefined) {
-        const wanted = Array.isArray(declaredType) ? declaredType.map(String) : [String(declaredType)];
-        if (!wanted.some((want) => matchesType(value, want))) {
-            issues.push({ path, message: `expected ${wanted.join(" or ")}, got ${typeOf(value)}` });
-            return; // A wrong type makes the remaining checks noise.
-        }
-    }
-    if (Array.isArray(schema.enum) && !schema.enum.some((option) => JSON.stringify(option) === JSON.stringify(value))) {
-        issues.push({ path, message: `must be one of ${schema.enum.map((option) => JSON.stringify(option)).join(", ")}` });
-    }
-    if (isObject(value)) {
-        const properties = isObject(schema.properties) ? schema.properties : {};
-        if (Array.isArray(schema.required)) {
-            for (const key of schema.required.map(String)) {
-                if (!(key in value))
-                    issues.push({ path: path ? `${path}.${key}` : key, message: "is required" });
-            }
-        }
-        for (const [key, propertySchema] of Object.entries(properties)) {
-            if (key in value)
-                validateNode(value[key], propertySchema, root, path ? `${path}.${key}` : key, issues);
-        }
-        if (schema.additionalProperties === false) {
-            for (const key of Object.keys(value)) {
-                if (!(key in properties))
-                    issues.push({ path: path ? `${path}.${key}` : key, message: "is not an allowed property" });
-            }
-        }
-        else if (isObject(schema.additionalProperties)) {
-            for (const [key, entry] of Object.entries(value)) {
-                if (!(key in properties))
-                    validateNode(entry, schema.additionalProperties, root, path ? `${path}.${key}` : key, issues);
-            }
-        }
-    }
-    if (Array.isArray(value) && schema.items !== undefined) {
-        const items = schema.items;
-        if (Array.isArray(items)) {
-            // Tuple form: validate positionally.
-            value.forEach((entry, index) => {
-                if (index < items.length)
-                    validateNode(entry, items[index], root, `${path}[${index}]`, issues);
-            });
-        }
-        else {
-            value.forEach((entry, index) => validateNode(entry, items, root, `${path}[${index}]`, issues));
-        }
-    }
-    if (typeof value === "string") {
-        if (typeof schema.minLength === "number" && value.length < schema.minLength) {
-            issues.push({ path, message: `is shorter than ${schema.minLength} characters` });
-        }
-        if (typeof schema.pattern === "string") {
-            try {
-                if (!new RegExp(schema.pattern).test(value))
-                    issues.push({ path, message: `does not match ${schema.pattern}` });
-            }
-            catch {
-                // An invalid pattern is the schema author's problem, not the value's.
-            }
-        }
-    }
-    if (typeof value === "number") {
-        if (typeof schema.minimum === "number" && value < schema.minimum)
-            issues.push({ path, message: `is below ${schema.minimum}` });
-        if (typeof schema.maximum === "number" && value > schema.maximum)
-            issues.push({ path, message: `is above ${schema.maximum}` });
-    }
-}
-/** Every way `value` fails `schema`. Empty means it validates. */
-export function validateSchema(value, schema) {
-    if (!isObject(schema))
-        return [];
-    const issues = [];
-    validateNode(value, schema, schema, "", issues);
-    return issues;
-}
-/** One line per issue, for a repair turn. */
-export function formatIssues(issues) {
-    return issues.map((issue) => `- ${issue.path || "(root)"}: ${issue.message}`).join("\n");
-}
-/**
- * Pull a JSON value out of a model reply.
- *
- * Models wrap JSON in prose or fences often enough that a bare `JSON.parse` is
- * not a fair test of whether they followed the schema. Only the first complete
- * value is taken; anything before or after it is ignored.
- */
-export function extractJson(text) {
-    const trimmed = text.trim();
-    const fenced = /```(?:json)?\s*([\s\S]*?)```/.exec(trimmed);
-    const candidates = [trimmed, fenced?.[1]?.trim()].filter((candidate) => Boolean(candidate));
-    for (const candidate of candidates) {
-        try {
-            return JSON.parse(candidate);
-        }
-        catch {
-            /* try to find a balanced value inside */
-        }
-        for (let start = 0; start < candidate.length; start++) {
-            const opener = candidate[start];
-            if (opener !== "{" && opener !== "[")
-                continue;
-            const closer = opener === "{" ? "}" : "]";
-            let depth = 0;
-            let inString = false;
-            let escaped = false;
-            for (let index = start; index < candidate.length; index++) {
-                const char = candidate[index];
-                if (inString) {
-                    if (escaped)
-                        escaped = false;
-                    else if (char === "\\")
-                        escaped = true;
-                    else if (char === '"')
-                        inString = false;
-                    continue;
-                }
-                if (char === '"')
-                    inString = true;
-                else if (char === opener)
-                    depth++;
-                else if (char === closer) {
-                    depth--;
-                    if (depth === 0) {
-                        try {
-                            return JSON.parse(candidate.slice(start, index + 1));
-                        }
-                        catch {
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return undefined;
-}

package/dist/session-lifecycle.js

@@ -1,19 +0,0 @@
-/**
- * Close extension-owned resources before disposing an agent session.
- *
- * AgentSession.dispose() disconnects the agent itself, but extension resources
- * (including MCP transports) are released by the session_shutdown event. The
- * SDK exposes the runner so callers can deliver that lifecycle event even when
- * a session is replaced outside the interactive mode.
- *
- * The returned promise settles once the shutdown has been delivered and the
- * session is disposed. Callers must await it: dropping the promise leaves the
- * MCP processes and tool registrations alive after the configuration that
- * created them is gone.
- */
-export function disposeAgentSession(session) {
-    return session.extensionRunner
-        .emit({ type: "session_shutdown", reason: "quit" })
-        .catch(() => undefined)
-        .finally(() => session.dispose());
-}

package/dist/session-retention.js

@@ -1,111 +0,0 @@
-import { readdir, rmdir, stat, unlink } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { RETENTION_DAYS } from "./checkpoint.js";
-import { AGENT_DIR } from "./paths.js";
-/**
- * Unlink session files idle for longer than `RETENTION_DAYS`, across every
- * project directory — the store's whole problem is that it is per-cwd and
- * nothing ever looked outside the current one.
- *
- * The SDK writes `<agentDir>/sessions/--<encoded-cwd>--/<timestamp>_<id>.jsonl`
- * and never removes one: `SessionManager` only appends, the TUI's delete is a
- * single user-chosen session (and prefers `trash`), and the CLI had no sweep at
- * all, so a machine that uses the product for a year keeps a transcript of every
- * folder it was ever pointed at. Rewind's shadow store already sweeps at 30 days
- * (checkpoint.ts, `RETENTION_DAYS`) — same window here on purpose, so "old" means
- * one thing across both stores and a session whose snapshots are gone does not
- * linger as a transcript.
- *
- * Age is the file's mtime, not the timestamp in its name: a session resumed last
- * week was written last week and must survive, while its filename still says the
- * day it was created. `keep` is the stronger rule on top of that — `--continue`
- * and `/resume` exist to bring an old session back, so the file this process just
- * opened is kept whatever its age.
- *
- * Housekeeping, so it never throws and never reports to the user: every step is
- * per-file, an error only leaves the store larger than it needed to be. Files are
- * unlinked rather than trashed — the TUI's `trash` path is a person deleting one
- * session they chose, this is a bulk sweep they did not ask to watch.
- */
-export async function sweepStaleSessions(options = {}) {
-    const result = { removed: [], failed: [], removedDirs: [] };
-    const root = join(options.agentDir ?? AGENT_DIR, "sessions");
-    const cutoff = (options.now ?? Date.now()) - RETENTION_DAYS * 24 * 60 * 60 * 1000;
-    const keep = options.keep ? resolve(options.keep) : undefined;
-    let projects;
-    try {
-        projects = await readdir(root, { withFileTypes: true });
-    }
-    catch {
-        // No store, or an unreadable one: nothing to sweep and nothing to say.
-        return result;
-    }
-    for (const project of projects) {
-        if (!project.isDirectory())
-            continue;
-        const dir = join(root, project.name);
-        let files;
-        try {
-            files = await readdir(dir);
-        }
-        catch {
-            continue;
-        }
-        // What will still be in the directory when the sweep is done. Sidecars a
-        // stale session left behind (`plan.md`, `plan_mode.json`) count and keep the
-        // directory on purpose: they are project state a later session of the same
-        // folder still restores.
-        const surviving = files.filter((file) => !file.endsWith(".jsonl"));
-        for (const file of files) {
-            if (!file.endsWith(".jsonl"))
-                continue;
-            const path = join(dir, file);
-            let stale;
-            try {
-                if (keep && resolve(path) === keep)
-                    stale = false;
-                else {
-                    // mtime, not the timestamp in the name: a session resumed last week
-                    // was written last week, whatever its filename says.
-                    stale = (await stat(path)).mtimeMs < cutoff;
-                }
-            }
-            catch {
-                // Raced with another sweeper (two processes starting at once).
-                stale = false;
-            }
-            if (!stale) {
-                surviving.push(file);
-                continue;
-            }
-            try {
-                await unlink(path);
-                result.removed.push(path);
-            }
-            catch {
-                // A directory called `x.jsonl`, a permission wall, a file another
-                // process holds oddly: count it and keep going.
-                result.failed.push(path);
-                surviving.push(file);
-            }
-        }
-        // Drop the per-project directory when nothing is left in it, so the encoded
-        // cwd names stop piling up too.
-        if (surviving.length === 0) {
-            // Never drop the directory the live session writes into. On a fresh start
-            // the session file does not exist yet, so the directory looks empty and
-            // the sweep removed it — the next prompt then failed with ENOENT because
-            // the writer's parent had been deleted underneath it.
-            if (keep && dirname(keep) === dir)
-                continue;
-            try {
-                await rmdir(dir);
-                result.removedDirs.push(dir);
-            }
-            catch {
-                // Non-empty after all, or racing a writer: the directory stays.
-            }
-        }
-    }
-    return result;
-}