@mafdet/cli 0.4.0 → 0.4.2

package/dist/tui/start-agent.js

@@ -9,6 +9,13 @@ import { buildToolset, READ_ONLY_PROMPT, WRITE_PROMPT, } from "../commands/agent
 import { buildRuntime } from "../commands/runtime.js";
 import { Workspace } from "../filesystem/workspace.js";
 import { ExitCode } from "../output/exit-codes.js";
+import { existsSync, writeFileSync } from "node:fs";
+import { sessionsDir } from "../config/paths.js";
+import { keyDigest } from "../security/redact.js";
+import { SessionRecorder } from "../sessions/recorder.js";
+import { SessionWriter } from "../sessions/store.js";
+import { NOTICE_FILE, decideRecording, firstSaveNotice, } from "../sessions/policy.js";
+import { describeResume, openForResume } from "../sessions/open.js";
 import { runAgentSurface } from "./agent-surface.js";
 import { palette } from "./theme.js";
 /**
@@ -17,6 +24,32 @@ import { palette } from "./theme.js";
  * The same spellings the agent command uses, so there is one grammar for
  * granting these and no second one to keep in step.
  */
+/** `--no-history` and `--title`, read off the bare invocation. */
+export function parseSessionOptions(argv) {
+    let title;
+    for (let i = 0; i < argv.length; i += 1) {
+        if (argv[i] !== "--title")
+            continue;
+        const value = argv[i + 1];
+        if (value !== undefined && !value.startsWith("-")) {
+            title = value;
+            i += 1;
+        }
+    }
+    let resumeId;
+    for (let i = 0; i < argv.length; i += 1) {
+        if (argv[i] !== "--resume")
+            continue;
+        const value = argv[i + 1];
+        if (value !== undefined && !value.startsWith("-"))
+            resumeId = value;
+    }
+    return {
+        noHistory: argv.includes("--no-history"),
+        ...(title === undefined ? {} : { title }),
+        ...(resumeId === undefined ? {} : { resumeId }),
+    };
+}
 export function parsePermissions(argv) {
     let allowWrite = false;
     const allowedCommands = [];
@@ -58,10 +91,42 @@ export async function startAgent(options) {
             ? ` - commands: ${options.permissions.allowedCommands.join(", ")}`
             : "") +
         "\n  type a goal, or /help for the session commands\n\n"));
+    const opened = options.session?.resumeId
+        ? openForResume({
+            root: sessionsDir(options.commandIo.env ?? process.env),
+            sessionId: options.session.resumeId,
+            systemPrompt: mode === "read-only" ? READ_ONLY_PROMPT : WRITE_PROMPT,
+            callable: [options.model.modelId],
+            agentCapable: options.model.agentEligible
+                ? [options.model.modelId]
+                : [],
+            allowedCommandsThisRun: options.permissions.allowedCommands,
+        })
+        : undefined;
+    if (opened !== undefined && opened.kind !== "opened") {
+        options.stdout.write(`\n  ${bold("cannot resume that conversation")}: ${opened.kind === "missing"
+            ? "no session with that id on this computer"
+            : opened.reason}\n\n`);
+        return ExitCode.General;
+    }
+    if (opened !== undefined)
+        options.stdout.write(dim(describeResume(opened)));
+    const recorder = opened !== undefined
+        ? new SessionRecorder({
+            writer: opened.writer,
+            root: sessionsDir(options.commandIo.env ?? process.env),
+            apiKeyRef: keyDigest(options.apiKey),
+            onProblem: (message) => void options.stdout.write(dim(`  ${message}\n`)),
+        })
+        : startRecording(options, mode);
     await runAgentSurface({
         io: options.io,
+        ...(recorder === undefined ? {} : { recorder }),
         capabilities: options.capabilities,
         stdout: options.stdout,
+        ...(options.getSignal === undefined
+            ? {}
+            : { getSignal: options.getSignal }),
         session: {
             client: runtime.dataPlane,
             model: options.model.modelId,
@@ -74,9 +139,68 @@ export async function startAgent(options) {
                 allowedCommands: options.permissions.allowedCommands,
             },
             mode,
+            // The rebuilt conversation, or nothing for a new session. runSession
+            // appends to this array in place, which is what continues the thread.
+            ...(opened === undefined ? {} : { history: opened.messages }),
             allowedCommands: options.permissions.allowedCommands,
-            ...(options.signal === undefined ? {} : { signal: options.signal }),
         },
     });
     return ExitCode.Ok;
 }
+/**
+ * Open a recorder for this run, or not.
+ *
+ * Returns undefined for `--no-history`, and - importantly - reaches the
+ * filesystem only when it is going to record. A flag that still created an
+ * empty directory would be a flag the user was right not to trust.
+ */
+function startRecording(options, mode) {
+    const decision = decideRecording({
+        surface: "interactive",
+        noHistory: options.session?.noHistory ?? false,
+        save: false,
+    });
+    if (!decision.record)
+        return undefined;
+    const env = options.commandIo.env ?? process.env;
+    const root = sessionsDir(env);
+    try {
+        const writer = SessionWriter.create({
+            root,
+            title: options.session?.title ?? defaultTitle(options.workspace),
+            modelId: options.model.modelId,
+            workspace: options.workspace,
+            mode,
+        });
+        showNoticeOnce(root, options);
+        return new SessionRecorder({
+            writer,
+            root,
+            apiKeyRef: keyDigest(options.apiKey),
+            onProblem: (message) => void options.stdout.write(palette(options.capabilities).dim(`  ${message}\n`)),
+        });
+    }
+    catch (error) {
+        // A store that cannot be opened is worth one line, not a dead session.
+        const message = error instanceof Error ? error.message : String(error);
+        options.stdout.write(palette(options.capabilities).dim(`  not recording this conversation: ${message}\n`));
+        return undefined;
+    }
+}
+/** The directory name is the most useful thing we know before anyone speaks. */
+function defaultTitle(workspace) {
+    const name = workspace.split(/[\\/]/).filter(Boolean).at(-1);
+    return name === undefined || name.length === 0 ? "Conversation" : name;
+}
+function showNoticeOnce(root, options) {
+    const marker = `${root}/${NOTICE_FILE}`;
+    try {
+        if (existsSync(marker))
+            return;
+        options.stdout.write(firstSaveNotice(root));
+        writeFileSync(marker, `${new Date().toISOString()}\n`, { mode: 0o600 });
+    }
+    catch {
+        // Showing it twice is a much smaller problem than failing to start.
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mafdet/cli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Mafdet AI command line — model calls, account queries, and a permissioned local agent.",
   "type": "module",
   "license": "MIT",