howtofixcli 0.7.7 → 0.7.9

package/dist/tools.js

@@ -1,176 +0,0 @@
-import { Type } from "@netrodev/hxf-ai";
-import { defineTool } from "@netrodev/hxf-coding-agent";
-import { relative, join } from "node:path";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { allClaims, claim, release } from "./claims.js";
-import { sessionsIn } from "./sessions.js";
-let asker;
-export function setAsker(next) {
-    asker = next;
-}
-export const thinkTool = defineTool({
-    name: "think",
-    label: "think",
-    description: "Private scratchpad. The text is not shown to the user. Use it before a non-obvious step.",
-    promptSnippet: "think: private notes, not shown to the user",
-    parameters: Type.Object({
-        thoughts: Type.String({ description: "Private notes" }),
-    }),
-    async execute() {
-        return { content: [{ type: "text", text: "noted" }], details: { recorded: true } };
-    },
-});
-export const askTool = defineTool({
-    name: "ask",
-    label: "ask",
-    description: "Ask the user one question and wait for a selected answer. Use this instead of guessing when a choice blocks the task.",
-    promptSnippet: "ask: ask the user to pick one option",
-    parameters: Type.Object({
-        question: Type.String(),
-        options: Type.Array(Type.String(), { minItems: 2 }),
-    }),
-    async execute(_toolCallId, params) {
-        if (!asker)
-            return { content: [{ type: "text", text: "cancelled" }], details: { answer: "cancelled" } };
-        const answer = await asker(params.question, params.options);
-        return { content: [{ type: "text", text: answer }], details: { answer } };
-    },
-});
-let claimsContext;
-export function setClaimsContext(next) {
-    claimsContext = next;
-}
-/**
- * `sessions` is the cross-session half of claims.
- *
- * A claim tells one session that a file is taken; this tells it by whom, and lets it
- * ask that session to let go. Without it a refusal names an opaque holder id and the
- * only way forward is to wait for a process the caller cannot see.
- */
-export const sessionsTool = defineTool({
-    name: "sessions",
-    label: "sessions",
-    description: "See the other HowToFix sessions working in this workspace, what they hold, and what they are doing. Use it to find who is blocking a claim, or to tell another session to release a file. Send a message with message + to.",
-    promptSnippet: "sessions: other CLI sessions, and who holds what",
-    parameters: Type.Object({
-        message: Type.Optional(Type.String({ description: "Message text to leave for another session." })),
-        to: Type.Optional(Type.String({ description: "Session id to send the message to. Use `all` for every other session." })),
-    }),
-    async execute(_toolCallId, params) {
-        const ctx = claimsContext;
-        const dir = ctx?.presenceDir?.();
-        if (!ctx || !dir) {
-            return { content: [{ type: "text", text: "the session registry is unavailable here" }], details: {} };
-        }
-        const self = ctx.selfId?.() ?? "";
-        const root = ctx.root();
-        // `sessionsIn` is the workspace-scoped view; the tool only ever reports sessions
-        // in this project, because a claim in another workspace is not this caller's
-        // business and naming it would only be noise.
-        const here = sessionsIn({ dir }, root);
-        if (params.message && params.message.trim()) {
-            const target = params.to?.trim() || "all";
-            const recipients = here.filter((s) => s.id !== self && (target === "all" || s.id === target));
-            if (recipients.length === 0) {
-                return {
-                    content: [{ type: "text", text: "no other session in this workspace to message" }],
-                    details: { sent: 0 },
-                };
-            }
-            for (const s of recipients) {
-                // Appended to the file rather than a queue of its own: the recipient reads it
-                // on its next discovery, and a message that outlives the sender is the point.
-                const box = join(dir, `${s.id.replace(/[^A-Za-z0-9._-]/g, "_")}.inbox`);
-                try {
-                    mkdirSync(dir, { recursive: true });
-                    writeFileSync(box, `${JSON.stringify({ from: self, at: Date.now(), text: params.message.trim() })}\n`, { flag: "a" });
-                }
-                catch {
-                    // A mailbox that cannot be written is not worth failing the call over; the
-                    // listing below still reports who is there.
-                }
-            }
-            return {
-                content: [{ type: "text", text: `left a message for ${recipients.map((s) => s.id).join(", ")}` }],
-                details: { sent: recipients.length },
-            };
-        }
-        if (here.length === 0) {
-            return { content: [{ type: "text", text: "no other session in this workspace" }], details: { sessions: [] } };
-        }
-        const lines = here.map((s) => {
-            const who = s.id === self ? "this session" : s.id;
-            const held = allClaims(root).filter((c) => c.holder === `session:${s.id}`);
-            const doing = s.activity ? ` — ${s.activity}` : "";
-            // The reason is the whole point of the listing: a caller that learns a file is
-            // taken but not WHY cannot judge whether to wait, ask, or work elsewhere.
-            const heldText = held.length > 0 ? `\n    holds:\n${held.map((c) => `      ${relativeFrom(root, c.path)} — ${c.reason}`).join("\n")}` : "";
-            return `  ${who} (pid ${s.pid}${s.id === self ? "" : `, seen ${Math.round((Date.now() - s.at) / 1000)}s ago`})${doing}${heldText}`;
-        });
-        return {
-            content: [{ type: "text", text: `sessions in ${root}:\n${lines.join("\n")}` }],
-            details: { sessions: here },
-        };
-    },
-});
-function renderClaimResult(result) {
-    const lines = [];
-    if (result.granted.length > 0)
-        lines.push(`claimed: ${result.granted.join(", ")}`);
-    if (result.conflicts.length > 0) {
-        lines.push("");
-        lines.push("refused — another agent is working on these:");
-        for (const c of result.conflicts)
-            lines.push(`  ${c.path} — held by ${c.by}: ${c.reason}`);
-        lines.push("");
-        lines.push("Wait for the holder to release it, or work on something else. Do not edit a refused path.");
-    }
-    if (lines.length === 0)
-        lines.push("nothing to claim");
-    return { text: lines.join("\n"), isError: result.conflicts.length > 0 };
-}
-export const claimTool = defineTool({
-    name: "claim",
-    label: "claim",
-    description: "Claim files or directories before editing them, so a parallel agent cannot overwrite your work. Refused paths are held by someone else — do not edit them. Pass no paths to list every claim in this workspace.",
-    promptSnippet: "claim: reserve files before editing",
-    parameters: Type.Object({
-        paths: Type.Optional(Type.Array(Type.String(), {
-            description: "Files or directories to claim. Omit to list the current claims.",
-        })),
-        reason: Type.Optional(Type.String({ description: "Why you are taking them, shown to a refused agent." })),
-        release: Type.Optional(Type.Boolean({ description: "Release these paths instead of claiming them. Omit paths to release everything you hold." })),
-    }),
-    async execute(_toolCallId, params) {
-        if (!claimsContext) {
-            return {
-                content: [{ type: "text", text: "claims are unavailable in this session" }],
-                details: {},
-                isError: true,
-            };
-        }
-        const root = claimsContext.root();
-        const holder = claimsContext.holder();
-        if (params.release) {
-            const freed = release(root, holder, params.paths);
-            return {
-                content: [{ type: "text", text: freed.length > 0 ? `released: ${freed.join(", ")}` : "you held nothing matching that" }],
-                details: { released: freed },
-            };
-        }
-        if (!params.paths || params.paths.length === 0) {
-            const all = allClaims(root);
-            if (all.length === 0)
-                return { content: [{ type: "text", text: "no active claims in this workspace" }], details: { claims: [] } };
-            const text = all.map((c) => `${c.holder === holder ? "(you) " : ""}${relativeFrom(root, c.path)} — ${c.reason}`).join("\n");
-            return { content: [{ type: "text", text }], details: { claims: all } };
-        }
-        const result = claim({ root, holder, reason: params.reason ?? "no reason given", paths: params.paths });
-        const { text, isError } = renderClaimResult(result);
-        return { content: [{ type: "text", text }], isError, details: result };
-    },
-});
-function relativeFrom(root, path) {
-    const rel = relative(root, path);
-    return rel && !rel.startsWith("..") ? rel : path;
-}