@datagusto/cli 0.0.0-stage → 0.2.0

package/dist/adapters/kiro.js

@@ -0,0 +1,752 @@
+// ---------------------------------------------------------------------------
+// dg CLI - Kiro adapter
+// ---------------------------------------------------------------------------
+//
+// Installs the bundled kiro plugin into one Kiro workspace:
+//
+//   <workspace>/
+//     dist/*.js, dist/package.json    the plugin
+//     kiro.json                       serverUrl + apiKey, mode 0600
+//     .kiro/hooks/datagusto-*.json    the plugin's five hooks, for `kiro-cli --v3`
+//     .kiro/agents/kiro_default.json  the same five hooks, for the default engine
+//     .kiro/.datagusto-install.json   ownership marker + file hashes
+//
+// This is the layout the plugin already expects: its hook files run
+// `node dist/index.js` relative to the workspace, and its loadConfig() reads
+// kiro.json from the folder above dist/. So the hook files are installed as
+// they are and the plugin runtime is unchanged (ADR-0003 TR-2, TR-8). The
+// plugin's package.json goes inside dist/, so node loads dist/*.js as ESM
+// whatever the workspace's own package.json says.
+//
+// Kiro CLI 2.x has two engines and they find hooks in different places.
+// `--v3` reads the standalone files in .kiro/hooks/. The default engine
+// ignores those and runs the hooks in the config of the session's agent; a
+// workspace agent file named kiro_default takes the built-in default agent's
+// place, so a plain `kiro-cli` runs the hooks in it. `--v3` does not run the
+// hooks in that file, so the two never fire together. If the workspace
+// already has a kiro_default.json it is the user's: only the plugin's hook
+// entries are merged in, and taken out again by clear (see kiro-agent.ts).
+//
+// There is a third engine, V1, which runs when the Kiro setting
+// chat.agentEngine is "v1" or, per `kiro-cli chat --help`, when a session is
+// started with `--agent-engine v1` (the flag was not tried). It does not let
+// a workspace kiro_default replace the built-in agent and does not read
+// .kiro/hooks/, so nothing dg installs runs under it. dg cannot fix that from
+// the workspace; doctor reads the setting and reports it with the command
+// that switches the workspace back. doctor can only see the setting: a flag
+// passed on the command line leaves no trace, so a `--agent-engine v1`
+// session is unchecked while every check passes. The default-engine check's
+// own text says so.
+//
+// The workspace belongs to the user (TR-5), and unlike Claude Code there is
+// no folder that is only ours. Ownership is therefore per file: the marker
+// lists every file dg installed with its hash. A file at one of our paths
+// that the marker doesn't list is a conflict, and setup stops before writing
+// anything. clear() removes only files that still match their hash, so a
+// build that has since written its own dist/index.js is left alone.
+//
+// Every new file is first written next to its target, and only then are
+// they renamed into place, hook files and then the agent config last. A
+// setup that fails part-way leaves the previous install (or nothing) behind.
+//
+// Verified on Kiro CLI 2.27 only. The Kiro IDE reads the same hook files, but
+// whether it runs them the same way is unconfirmed; doctor says so.
+import { execFile } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { access, constants, copyFile, lstat, mkdir, readFile, rename, rm, rmdir, stat } from "node:fs/promises";
+import { basename, dirname, join, posix, relative, sep } from "node:path";
+import { promisify } from "node:util";
+import { DatagustoApiClient } from "../api/client.js";
+import { explainApiError } from "../api/errors.js";
+import { tildify } from "../display.js";
+import { renameWithRetry, writeFileAtomic } from "../fs/atomic.js";
+import { hasUnixPermissions, isWindows, onPath } from "../platform.js";
+import { changedFiles, hashFile, loadVendoredPlugin, VendorError } from "../vendor.js";
+import { addAgentHooks, agentHooks, eventsWithAgentHooks, hashText, readAgentFile, removeAgentHooks, serializeAgent, writeAgentFile, } from "./kiro-agent.js";
+import { AdapterError, } from "./types.js";
+const VENDOR_NAME = "kiro";
+const CONFIG_FILE = "kiro.json";
+const HOOKS_DIR = ".kiro/hooks";
+const MARKER_FILE = ".kiro/.datagusto-install.json";
+const INSTALLED_BY = "@datagusto/cli";
+/** The default engine's hooks: a workspace agent that stands in for the built-in default. */
+const DEFAULT_AGENT = "kiro_default";
+const AGENT_CONFIG = `.kiro/agents/${DEFAULT_AGENT}.json`;
+/** Kiro's own settings, workspace then user. Only ever read. */
+const KIRO_SETTINGS = ".kiro/settings/cli.json";
+const DEFAULT_AGENT_SETTING = "chat.defaultAgent";
+/** Which engine a plain `kiro-cli` runs: "v1", "v2" (Kiro's default) or "v3". */
+const AGENT_ENGINE_SETTING = "chat.agentEngine";
+/** The engine that runs none of the hooks dg installs. */
+const UNSUPPORTED_ENGINE = "v1";
+const DEFAULT_ENGINE = "v2";
+const KIRO_CLI_INSTALL = "curl -fsSL https://cli.kiro.dev/install | bash";
+/** How to install the Kiro CLI on this operating system. */
+function kiroInstallHint(platform) {
+    if (isWindows(platform))
+        return "the Windows installer from kiro.dev";
+    const viaBrew = (platform ?? process.platform) === "darwin" ? " (or `brew install --cask kiro-cli`)" : "";
+    return `\`${KIRO_CLI_INSTALL}\`${viaBrew}`;
+}
+// On the default engine hooks belong to an agent, so only sessions running the default agent get them.
+const AGENT_CAVEAT = "On the default engine only the default agent runs the hooks: a session started with `--agent <name>` " +
+    "or switched with `/agent` to another agent is not protected. Neither is one started with `--agent-engine v1`, " +
+    "which dg can't detect.";
+const IDE_CAVEAT = "Kiro IDE is not verified: use the Kiro CLI (`kiro-cli`) in this workspace.";
+const UNPROTECTED = "a plain `kiro-cli` session in this workspace is not protected";
+/** True for a hook entry that runs the plugin: every hook dg installs uses this command. */
+const PLUGIN_COMMAND = "node dist/index.js";
+const runsPlugin = (command) => command.trim() === PLUGIN_COMMAND;
+export class KiroAdapter {
+    name = "kiro";
+    displayName = "Kiro";
+    perWorkspace = true;
+    whoami;
+    gitIgnores;
+    constructor(deps = {}) {
+        this.whoami = deps.whoami ?? ((serverUrl, apiKey) => new DatagustoApiClient({ serverUrl, apiKey }).whoami());
+        this.gitIgnores = deps.gitIgnores ?? runGitCheckIgnore;
+    }
+    async detect(ctx) {
+        const ws = workspaceOf(ctx);
+        if (!(await isDir(ws))) {
+            return {
+                found: false,
+                detail: `${ws} isn't a folder. Run this from your Kiro workspace, or pass it with --workspace <dir>.`,
+            };
+        }
+        // The Kiro IDE (`kiro`, ~/.kiro) isn't enough: the hooks are only verified on the CLI.
+        if (await onPath("kiro-cli", ctx.env, ctx.platform))
+            return { found: true };
+        return {
+            found: false,
+            detail: "The Kiro CLI isn't installed: there's no `kiro-cli` command on your PATH. Datagusto's hooks run in " +
+                "the Kiro CLI, and the Kiro IDE on its own is not enough. Install it with " +
+                kiroInstallHint(ctx.platform) +
+                ", sign in with `kiro-cli login`, open a new terminal, then run this again.",
+        };
+    }
+    async preflight(ctx) {
+        const ws = workspaceOf(ctx);
+        const plugin = await loadVendoredPlugin(ctx.vendorDir, VENDOR_NAME);
+        const owner = await ownership(ws);
+        await refuseConflicts(ws, installedFiles(plugin), owner, ctx.homeDir);
+        // Read now so a broken agent config stops setup before the key is asked for.
+        await planAgentConfig(ws, join(ctx.vendorDir, VENDOR_NAME), plugin, owner);
+    }
+    async plan(ctx, _conn) {
+        const ws = workspaceOf(ctx);
+        const plugin = await loadVendoredPlugin(ctx.vendorDir, VENDOR_NAME);
+        const files = installedFiles(plugin);
+        const owner = await ownership(ws);
+        await refuseConflicts(ws, files, owner, ctx.homeDir);
+        const update = owner.state === "ours";
+        const agent = await planAgentConfig(ws, join(ctx.vendorDir, VENDOR_NAME), plugin, owner);
+        const changes = [
+            {
+                kind: "copy-dir",
+                path: join(ws, "dist"),
+                description: `${update ? "Update" : "Install"} the Datagusto safety plugin v${plugin.pluginVersion}`,
+            },
+            {
+                kind: update ? "update-file" : "create-file",
+                path: join(ws, CONFIG_FILE),
+                description: "Save the server URL and API key (readable only by you)",
+            },
+            {
+                kind: "copy-dir",
+                path: join(ws, ...HOOKS_DIR.split("/")),
+                description: `Add the plugin's ${hookFiles(files).length} hooks for \`kiro-cli --v3\` (your other hooks are left as they are)`,
+            },
+            agent.action === "merge"
+                ? {
+                    kind: "merge-json",
+                    path: agent.file.path,
+                    description: `Add the plugin's ${agent.events} hooks to your default agent, for plain \`kiro-cli\` (the rest of the file is left as it is)`,
+                }
+                : {
+                    kind: agent.action === "create" ? "create-file" : "update-file",
+                    path: agent.file.path,
+                    description: `${agent.action === "create" ? "Add" : "Update"} the default agent that runs the plugin's ${agent.events} hooks, for plain \`kiro-cli\``,
+                },
+        ];
+        return { agent: this.name, changes };
+    }
+    async apply(ctx, _plan, conn) {
+        const ws = workspaceOf(ctx);
+        const src = join(ctx.vendorDir, VENDOR_NAME);
+        const plugin = await loadVendoredPlugin(ctx.vendorDir, VENDOR_NAME);
+        const damaged = await changedFiles(src, plugin.files);
+        if (damaged.length > 0) {
+            throw new AdapterError(`The plugin files bundled with dg are damaged (${damaged.join(", ")}). ` +
+                "Reinstall the CLI: npm install -g @datagusto/cli");
+        }
+        const files = installedFiles(plugin);
+        const owner = await ownership(ws);
+        await refuseConflicts(ws, files, owner, ctx.homeDir);
+        const update = owner.state === "ours";
+        const agent = await planAgentConfig(ws, src, plugin, owner);
+        // A re-run keeps any other options the user put in kiro.json
+        // (verbose, monitorOnly, …).
+        const previous = update ? await readJsonObject(join(ws, CONFIG_FILE)) : {};
+        const config = { ...previous, serverUrl: conn.serverUrl, apiKey: conn.apiKey };
+        const targets = [...Object.keys(files), CONFIG_FILE, MARKER_FILE, AGENT_CONFIG];
+        const at = (rel) => join(ws, ...rel.split("/"));
+        const suffix = randomBytes(4).toString("hex");
+        const createdDirs = [];
+        const staged = [];
+        const stage = async (rel, write) => {
+            const to = at(rel);
+            const tmp = join(dirname(to), `.${basename(to)}.${suffix}.tmp`);
+            staged.push({ tmp, to });
+            await write(tmp);
+        };
+        try {
+            for (const rel of targets)
+                await makeDirs(ws, posix.dirname(rel), createdDirs);
+            const marker = {
+                installedBy: INSTALLED_BY,
+                cliVersion: ctx.cliVersion,
+                pluginVersion: plugin.pluginVersion,
+                files,
+                createdDirs: [...new Set([...(update ? owner.marker.createdDirs : []), ...createdDirs])],
+                agentConfig: agent.marker,
+            };
+            // Hook files go last: Kiro must never see a hook whose script isn't there yet.
+            const hooks = hookFiles(files);
+            const copy = (rel) => stage(rel, (tmp) => copyFile(join(src, ...vendorPath(rel).split("/")), tmp));
+            for (const rel of Object.keys(files).filter((f) => !hooks.includes(f)))
+                await copy(rel);
+            await stage(CONFIG_FILE, (tmp) => writeFileAtomic(tmp, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 }));
+            await stage(MARKER_FILE, (tmp) => writeFileAtomic(tmp, JSON.stringify(marker, null, 2) + "\n"));
+            for (const rel of hooks)
+                await copy(rel);
+            for (const { tmp, to } of staged)
+                await renameWithRetry(tmp, to);
+            // The agent config goes last and in one step: it may be the user's own
+            // file, so there must be nothing left to fail once it has changed.
+            await writeAgentFile(agent.file, agent.text);
+        }
+        catch (err) {
+            for (const { tmp, to } of staged) {
+                await rm(tmp, { force: true });
+                // Nothing was here before a first install, so take back what got renamed.
+                if (!update)
+                    await rm(to, { force: true });
+            }
+            await removeEmptyDirs(ws, createdDirs);
+            throw err;
+        }
+        // Files an older plugin version had that this one doesn't.
+        if (update) {
+            for (const [rel, hash] of Object.entries(owner.marker.files)) {
+                if (!(rel in files) && (await hashOrUndefined(at(rel))) === hash)
+                    await rm(at(rel), { force: true });
+            }
+        }
+        return {
+            agent: this.name,
+            workspace: ws,
+            agentId: conn.agentId,
+            paths: targets.map(at),
+            installedAt: new Date().toISOString(),
+            cliVersion: ctx.cliVersion,
+        };
+    }
+    async clear(ctx, record) {
+        const result = { removed: [], edited: [], skipped: [] };
+        const ws = record.workspace ?? workspaceOf(ctx);
+        const markerPath = join(ws, ...MARKER_FILE.split("/"));
+        const owner = await ownership(ws);
+        if (owner.state !== "ours") {
+            // Without the marker, nothing here can be told from the user's own files.
+            for (const path of record.paths) {
+                if (path !== markerPath && (await exists(path)))
+                    result.skipped.push(path);
+            }
+            return result;
+        }
+        const rel = (path) => relative(ws, path).split(sep).join("/");
+        const isHook = (path) => rel(path).startsWith(`${HOOKS_DIR}/`) || rel(path) === AGENT_CONFIG;
+        // Hooks first: a hook left pointing at a deleted dist/index.js would error on every call.
+        const paths = [...record.paths.filter(isHook), ...record.paths.filter((p) => !isHook(p) && p !== markerPath)];
+        for (const path of paths) {
+            if (!(await exists(path)))
+                continue;
+            if (rel(path) === AGENT_CONFIG) {
+                const outcome = await clearAgentConfig(path, owner.marker.agentConfig);
+                if (outcome)
+                    result[outcome].push(path);
+                continue;
+            }
+            const hash = owner.marker.files[rel(path)];
+            const ours = rel(path) === CONFIG_FILE || (hash !== undefined && (await hashOrUndefined(path)) === hash);
+            if (ours) {
+                await rm(path, { force: true });
+                result.removed.push(path);
+            }
+            else {
+                // Changed since setup, e.g. the workspace's own build wrote dist/index.js.
+                result.skipped.push(path);
+            }
+        }
+        await rm(markerPath, { force: true });
+        result.removed.push(markerPath);
+        await removeEmptyDirs(ws, owner.marker.createdDirs);
+        return result;
+    }
+    async doctor(ctx, record) {
+        const report = { agent: this.name, checks: [] };
+        const add = (check) => report.checks.push(check);
+        const ws = record.workspace ?? workspaceOf(ctx);
+        const again = `Run \`dg setup kiro --workspace ${ws}\` again`;
+        add((await onPath("kiro-cli", ctx.env, ctx.platform))
+            ? { name: "Kiro CLI", status: "ok", detail: `found on your PATH. ${IDE_CAVEAT}` }
+            : { name: "Kiro CLI", status: "warn", detail: `\`kiro-cli\` isn't on your PATH. Install it with ${kiroInstallHint(ctx.platform)}. ${IDE_CAVEAT}`,
+            });
+        const owner = await ownership(ws);
+        if (owner.state !== "ours") {
+            add({
+                name: "Plugin files",
+                status: "fail",
+                detail: `${tildify(ws, ctx.homeDir)} no longer has the install dg made. ${again} to reinstall it.`,
+            });
+            return report;
+        }
+        const changed = await changedFiles(ws, owner.marker.files);
+        const hooks = hookFiles(owner.marker.files);
+        const changedPlugin = changed.filter((f) => !hooks.includes(f));
+        const changedHooks = changed.filter((f) => hooks.includes(f));
+        add(changedPlugin.length === 0
+            ? { name: "Plugin files", status: "ok", detail: `${tildify(join(ws, "dist"), ctx.homeDir)} (v${owner.marker.pluginVersion})` }
+            : {
+                name: "Plugin files",
+                status: "fail",
+                detail: `Changed or missing: ${changedPlugin.join(", ")}. ${again} to repair them.`,
+            });
+        add(changedHooks.length === 0
+            ? { name: V3_HOOKS, status: "ok", detail: `${hooks.length} hook files in ${HOOKS_DIR}` }
+            : {
+                name: V3_HOOKS,
+                status: "fail",
+                detail: `Changed or missing: ${changedHooks.join(", ")}, so a \`kiro-cli --v3\` session is not fully protected. ${again} to repair them.`,
+            });
+        for (const check of await defaultEngineChecks(ws, ctx.homeDir, owner.marker, again))
+            add(check);
+        for (const check of await agentEngineChecks(ws, ctx.homeDir))
+            add(check);
+        try {
+            const bundled = installedFiles(await loadVendoredPlugin(ctx.vendorDir, VENDOR_NAME));
+            if (!sameFiles(bundled, owner.marker.files)) {
+                add({
+                    name: "Plugin version",
+                    status: "warn",
+                    detail: `This dg bundles a different plugin build than the v${owner.marker.pluginVersion} installed here. ${again} to update it.`,
+                });
+            }
+        }
+        catch {
+            // A broken CLI package is setup's problem; status still reports the rest.
+        }
+        const configPath = join(ws, CONFIG_FILE);
+        const config = await readJsonObject(configPath);
+        const serverUrl = typeof config.serverUrl === "string" ? config.serverUrl : "";
+        const apiKey = typeof config.apiKey === "string" ? config.apiKey : "";
+        if (!serverUrl || !apiKey) {
+            add({
+                name: "Config",
+                status: "fail",
+                detail: `${tildify(configPath, ctx.homeDir)} has no server URL or API key. ${again}.`,
+            });
+            return report;
+        }
+        // Windows has no mode bits to check: the user profile's access rules keep the file private.
+        const fileMode = hasUnixPermissions(ctx.platform) ? (await stat(configPath)).mode & 0o777 : 0o600;
+        if (fileMode & 0o077) {
+            add({
+                name: "Config",
+                status: "warn",
+                detail: `${tildify(configPath, ctx.homeDir)} holds your API key but other users can read it. Run: chmod 600 ${configPath}`,
+            });
+        }
+        else if ((await this.gitIgnores(ws, CONFIG_FILE, ctx.env)) === false) {
+            add({
+                name: "Config",
+                status: "warn",
+                detail: `${CONFIG_FILE} holds your API key and git isn't ignoring it. Add ${CONFIG_FILE} to this workspace's .gitignore.`,
+            });
+        }
+        else {
+            add({ name: "Config", status: "ok", detail: serverUrl });
+        }
+        const who = await this.whoami(serverUrl, apiKey);
+        if (!who.ok) {
+            add({ name: "API key", status: "fail", detail: explainApiError(who, serverUrl) });
+            return report;
+        }
+        report.agentName = who.data.name;
+        add(who.data.agent_id === record.agentId
+            ? { name: "API key", status: "ok", detail: `agent "${who.data.name}"` }
+            : {
+                name: "API key",
+                status: "warn",
+                detail: `The key now belongs to agent "${who.data.name}", not the one it was set up with. ` +
+                    `${again} if that's not what you want.`,
+            });
+        return report;
+    }
+    async installedServerUrl(ctx) {
+        const ws = workspaceOf(ctx);
+        if ((await ownership(ws)).state !== "ours")
+            return undefined;
+        const config = await readJsonObject(join(ws, CONFIG_FILE));
+        return typeof config.serverUrl === "string" && config.serverUrl ? config.serverUrl : undefined;
+    }
+    nextSteps(ctx) {
+        const ws = workspaceOf(ctx);
+        return [
+            `Start \`kiro-cli\` in ${tildify(ws, ctx.homeDir)} to begin sending safety events: the hooks only run for sessions opened in that folder.`,
+            `Both engines are covered: plain \`kiro-cli\` through ${AGENT_CONFIG}, and \`kiro-cli --v3\` through ${HOOKS_DIR}/.`,
+            AGENT_CAVEAT,
+            IDE_CAVEAT,
+            `${CONFIG_FILE} in that folder holds your API key. Keep it out of git.`,
+        ];
+    }
+}
+// -- Internal helpers ---------------------------------------------------------
+function workspaceOf(ctx) {
+    if (!ctx.workspace)
+        throw new AdapterError("Kiro is set up one workspace at a time. Pass it with --workspace <dir>.");
+    return ctx.workspace;
+}
+/** Where a bundled file goes in the workspace. Only package.json moves. */
+function installPath(rel) {
+    return rel === "package.json" ? "dist/package.json" : rel;
+}
+function vendorPath(rel) {
+    return rel === "dist/package.json" ? "package.json" : rel;
+}
+/** The bundled files keyed by where they are installed, with their hashes. */
+function installedFiles(plugin) {
+    return Object.fromEntries(Object.entries(plugin.files)
+        // The agent config is merged, not copied: it can be the user's own file.
+        .filter(([rel]) => rel !== AGENT_CONFIG)
+        .map(([rel, hash]) => [installPath(rel), hash]));
+}
+const V3_HOOKS = "Hooks (--v3)";
+const DEFAULT_HOOKS = "Hooks (default engine)";
+/** The default engine's events the plugin has to be on. */
+const DEFAULT_ENGINE_EVENTS = ["agentSpawn", "userPromptSubmit", "preToolUse", "postToolUse", "stop"];
+/** The agent config dg bundles: the default agent plus the plugin's hooks. */
+async function bundledAgentConfig(vendorSrc, plugin) {
+    if (!(AGENT_CONFIG in plugin.files)) {
+        throw new VendorError(`This copy of dg doesn't include the Kiro agent config (${AGENT_CONFIG}). Reinstall the CLI: npm install -g @datagusto/cli`);
+    }
+    return readJsonObject(join(vendorSrc, ...AGENT_CONFIG.split("/")));
+}
+/**
+ * Work out the agent config setup will write. A file dg created and nobody
+ * has edited since is replaced with the bundled one; anything else that is
+ * already there is the user's, and only gets the plugin's hook entries.
+ */
+async function planAgentConfig(ws, vendorSrc, plugin, owner) {
+    const bundled = await bundledAgentConfig(vendorSrc, plugin);
+    const hooks = agentHooks(bundled, AGENT_CONFIG);
+    const file = await readAgentFile(join(ws, ...AGENT_CONFIG.split("/")));
+    const previous = owner.state === "ours" ? owner.marker.agentConfig : undefined;
+    let action;
+    let data;
+    if (!file.exists) {
+        action = "create";
+        data = bundled;
+    }
+    else if (previous?.created && file.hash === previous.hash) {
+        action = "replace";
+        data = bundled;
+    }
+    else {
+        action = "merge";
+        data = file.data;
+        removeAgentHooks(data, runsPlugin, file.path);
+        addAgentHooks(data, hooks, file.path);
+    }
+    const text = serializeAgent(data);
+    return {
+        file,
+        action,
+        text,
+        // Once the user's content is in the file it is never dg's to delete.
+        marker: { path: AGENT_CONFIG, created: action !== "merge", hash: hashText(text) },
+        events: Object.keys(hooks).length,
+    };
+}
+/**
+ * Undo the agent config: delete it if dg created it and it hasn't changed,
+ * otherwise take only the plugin's hook entries back out.
+ */
+async function clearAgentConfig(path, marker) {
+    if (!marker)
+        return "skipped";
+    let file;
+    try {
+        file = await readAgentFile(path);
+    }
+    catch (err) {
+        if (err instanceof AdapterError)
+            return "skipped";
+        throw err;
+    }
+    if (!file.exists)
+        return undefined;
+    if (marker.created && file.hash === marker.hash) {
+        await rm(file.path, { force: true });
+        return "removed";
+    }
+    if (removeAgentHooks(file.data, runsPlugin, path) === 0)
+        return undefined;
+    await writeAgentFile(file, serializeAgent(file.data));
+    return "edited";
+}
+/** Whether a plain `kiro-cli` session in `ws` runs the plugin's hooks. */
+async function defaultEngineChecks(ws, homeDir, marker, again) {
+    const path = join(ws, ...AGENT_CONFIG.split("/"));
+    const fail = (detail) => [{ name: DEFAULT_HOOKS, status: "fail", detail }];
+    if (!marker.agentConfig) {
+        return fail(`This install only covers \`kiro-cli --v3\`: ${UNPROTECTED}. ${again} to add the default engine's hooks.`);
+    }
+    let file;
+    try {
+        file = await readAgentFile(path);
+    }
+    catch (err) {
+        if (!(err instanceof AdapterError))
+            throw err;
+        return fail(`${AGENT_CONFIG} can't be read as an agent config, so ${UNPROTECTED}. Fix the file, then ${lower(again)}.`);
+    }
+    if (!file.exists)
+        return fail(`${AGENT_CONFIG} is missing, so ${UNPROTECTED}. ${again} to put it back.`);
+    const present = eventsWithAgentHooks(file.data, runsPlugin, path);
+    const missing = DEFAULT_ENGINE_EVENTS.filter((e) => !present.includes(e));
+    if (missing.length > 0) {
+        return fail(`${AGENT_CONFIG} no longer runs the plugin on ${missing.join(", ")}, so ${UNPROTECTED}. ${again} to repair it.`);
+    }
+    const checks = [
+        {
+            name: DEFAULT_HOOKS,
+            status: "ok",
+            detail: `${AGENT_CONFIG} runs the plugin on ${DEFAULT_ENGINE_EVENTS.length} events. ${AGENT_CAVEAT}`,
+        },
+    ];
+    // Kiro starts the agent named by chat.defaultAgent instead; the workspace's setting wins over the user's.
+    for (const settings of [join(ws, ...KIRO_SETTINGS.split("/")), join(homeDir, ...KIRO_SETTINGS.split("/"))]) {
+        const chosen = (await readJsonObject(settings))[DEFAULT_AGENT_SETTING];
+        if (typeof chosen !== "string" || chosen === "")
+            continue;
+        if (chosen !== DEFAULT_AGENT) {
+            checks.push({
+                name: "Default agent",
+                status: "warn",
+                detail: `${tildify(settings, homeDir)} sets ${DEFAULT_AGENT_SETTING} to "${chosen}", so a plain \`kiro-cli\` here starts that agent ` +
+                    `and not the one with the Datagusto hooks. Start sessions with \`kiro-cli --agent ${DEFAULT_AGENT}\` or \`kiro-cli --v3\`, ` +
+                    `or make it the default for this workspace: kiro-cli settings --workspace ${DEFAULT_AGENT_SETTING} ${DEFAULT_AGENT}`,
+            });
+        }
+        break;
+    }
+    const userAgent = join(homeDir, ...AGENT_CONFIG.split("/"));
+    if (await exists(userAgent)) {
+        checks.push({
+            name: "Your own default agent",
+            status: "warn",
+            detail: `You also have ${tildify(userAgent, homeDir)}. In this workspace Kiro uses ${AGENT_CONFIG} instead, ` +
+                "so copy anything you rely on from your own file into it.",
+        });
+    }
+    return checks;
+}
+/** The value of one of Kiro's own settings and the file that sets it; the workspace's wins over the user's. */
+async function kiroSetting(ws, homeDir, key) {
+    for (const file of [join(ws, ...KIRO_SETTINGS.split("/")), join(homeDir, ...KIRO_SETTINGS.split("/"))]) {
+        const value = (await readJsonObject(file))[key];
+        if (typeof value === "string" && value !== "")
+            return { value, file };
+    }
+    return undefined;
+}
+/**
+ * Whether Kiro's own settings put plain `kiro-cli` on the V1 engine, which
+ * runs none of the hooks dg installs. Only ever read: the engine is the
+ * user's choice to change.
+ *
+ * Severity follows the rule for every check here: fail when dg knows a plain
+ * session goes unchecked, warn when that depends on something dg doesn't
+ * manage. On V1 a plain session runs Kiro's built-in default agent, which has
+ * no hooks, so that is a failure. If chat.defaultAgent names another agent,
+ * the plain session runs that one, and whether it carries the Datagusto hooks
+ * is the user's business: a warning, as it is on the default engine.
+ *
+ * This sees the setting only. `kiro-cli --agent-engine v1` selects the same
+ * engine from the command line and cannot be detected (AGENT_CAVEAT says so).
+ */
+async function agentEngineChecks(ws, homeDir) {
+    const engine = await kiroSetting(ws, homeDir, AGENT_ENGINE_SETTING);
+    // Kiro documents the value as lowercase ("v1"). Whether it also accepts "V1"
+    // is unverified; matching it anyway costs nothing and errs towards warning.
+    if (!engine || engine.value.trim().toLowerCase() !== UNSUPPORTED_ENGINE)
+        return [];
+    const agent = await kiroSetting(ws, homeDir, DEFAULT_AGENT_SETTING);
+    const ownAgent = agent && agent.value !== DEFAULT_AGENT ? agent.value : undefined;
+    const intro = `${tildify(engine.file, homeDir)} sets ${AGENT_ENGINE_SETTING} to "${engine.value}". ` +
+        "Kiro's V1 engine doesn't run the Datagusto hooks that setup installs";
+    const fix = "`kiro-cli --v3` sessions here are still covered. " +
+        "Switch this workspace to Kiro's default engine by running this in the workspace: " +
+        `kiro-cli settings --workspace ${AGENT_ENGINE_SETTING} ${DEFAULT_ENGINE}`;
+    return [
+        ownAgent
+            ? {
+                name: "Agent engine",
+                status: "warn",
+                detail: `${intro}. A plain \`kiro-cli\` here starts your agent "${ownAgent}", so its tool calls are checked ` +
+                    `only if you added the Datagusto hooks to that agent yourself, which dg doesn't check. ${fix}`,
+            }
+            : {
+                name: "Agent engine",
+                status: "fail",
+                detail: `${intro}, so ${UNPROTECTED}: its tool calls run unchecked. ${fix}`,
+            },
+    ];
+}
+function lower(sentence) {
+    return sentence.charAt(0).toLowerCase() + sentence.slice(1);
+}
+function hookFiles(files) {
+    return Object.keys(files).filter((f) => f.startsWith(`${HOOKS_DIR}/`));
+}
+/** Stop if a file dg would write is already there and isn't one dg installed. */
+async function refuseConflicts(ws, files, owner, homeDir) {
+    const ours = new Set(owner.state === "ours" ? [...Object.keys(owner.marker.files), CONFIG_FILE, MARKER_FILE] : []);
+    const conflicts = [];
+    for (const rel of [...Object.keys(files), CONFIG_FILE, MARKER_FILE]) {
+        if (!ours.has(rel) && (await occupied(ws, rel)))
+            conflicts.push(rel);
+    }
+    if (conflicts.length > 0) {
+        throw new AdapterError(`${tildify(ws, homeDir)} already has ${conflicts.join(", ")}, which dg didn't put there, so nothing was changed. ` +
+            "The Kiro plugin needs those paths: move the files away or pick another --workspace, then run this again.");
+    }
+}
+async function ownership(ws) {
+    const marker = await readJsonObject(join(ws, ...MARKER_FILE.split("/")));
+    if (marker.installedBy !== INSTALLED_BY || typeof marker.files !== "object" || marker.files === null) {
+        return { state: "missing" };
+    }
+    const createdDirs = Array.isArray(marker.createdDirs) ? marker.createdDirs.filter((d) => typeof d === "string") : [];
+    return { state: "ours", marker: { ...marker, createdDirs } };
+}
+/** Create `relDir` under `ws` one level at a time, noting each folder made. */
+async function makeDirs(ws, relDir, created) {
+    if (relDir === ".")
+        return;
+    const parts = relDir.split("/");
+    for (let i = 1; i <= parts.length; i++) {
+        const rel = parts.slice(0, i).join("/");
+        try {
+            await mkdir(join(ws, ...parts.slice(0, i)), { mode: 0o755 });
+            created.push(rel);
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+        }
+    }
+}
+/** Remove `dirs` (deepest first) where they're empty; anything else stays. */
+async function removeEmptyDirs(ws, dirs) {
+    for (const rel of [...dirs].sort((a, b) => b.length - a.length)) {
+        if (rel.split("/").some((p) => p === ".." || p === ""))
+            continue;
+        try {
+            await rmdir(join(ws, ...rel.split("/")));
+        }
+        catch {
+            // not empty, or already gone
+        }
+    }
+}
+async function readJsonObject(path) {
+    try {
+        const v = JSON.parse(await readFile(path, "utf8"));
+        return typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+    }
+    catch {
+        return {};
+    }
+}
+function sameFiles(a, b) {
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((k) => a[k] === b[k]);
+}
+async function hashOrUndefined(path) {
+    try {
+        return await hashFile(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function exists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Like exists(), but a file where a parent folder should be also counts. */
+/**
+ * True when something already sits at `rel` inside `ws`, or a file sits where
+ * one of its folders should be (a file called `dist` blocks `dist/index.js`).
+ * macOS and Linux report the second case as ENOTDIR; Windows says ENOENT, so
+ * the folders on the way are checked one by one.
+ */
+async function occupied(ws, rel) {
+    const parts = rel.split("/");
+    try {
+        await lstat(join(ws, ...parts));
+        return true;
+    }
+    catch (err) {
+        if (err.code === "ENOTDIR")
+            return true;
+    }
+    for (let i = 1; i < parts.length; i++) {
+        try {
+            if (!(await lstat(join(ws, ...parts.slice(0, i)))).isDirectory())
+                return true;
+        }
+        catch {
+            return false; // that folder doesn't exist, so nothing below it does either
+        }
+    }
+    return false;
+}
+async function isDir(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** `git check-ignore`: exit 0 is ignored, 1 is not, anything else isn't a repo. */
+async function runGitCheckIgnore(workspace, file, env) {
+    try {
+        await promisify(execFile)("git", ["-C", workspace, "check-ignore", "-q", file], { env, timeout: 10_000 });
+        return true;
+    }
+    catch (err) {
+        return err.code === 1 ? false : undefined;
+    }
+}
+//# sourceMappingURL=kiro.js.map