@link-assistant/agent 0.26.0 → 0.26.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.26.0",
+  "version": "0.26.2",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",
@@ -50,8 +50,6 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@actions/core": "^1.11.1",
-    "@actions/github": "^6.0.1",
     "@agentclientprotocol/sdk": "^0.5.1",
     "@ai-sdk/amazon-bedrock": "^3.0.74",
     "@ai-sdk/anthropic": "^2.0.58",
@@ -134,5 +132,12 @@
       "prettier --check"
     ]
   },
-  "license": "Unlicense"
+  "license": "Unlicense",
+  "allowScripts": {
+    "@parcel/watcher@2.5.1": true,
+    "tree-sitter-bash@0.25.1": true
+  },
+  "overrides": {
+    "undici": "^7.16.0"
+  }
 }

package/src/agent/agent.ts

@@ -1,7 +1,7 @@
 import { Config } from '../config/file-config';
 import z from 'zod';
 import { Provider } from '../provider/provider';
-import { generateObject, type ModelMessage } from 'ai';
+import { generateObject } from 'ai';
 import PROMPT_GENERATE from './generate.txt';
 import { SystemPrompt } from '../session/system';
 import { Instance } from '../project/instance';
@@ -138,13 +138,14 @@ export namespace Agent {
     const existing = await list();
     const result = await generateObject({
       temperature: 0.3,
+      // The system prompt belongs in `system`, not in `prompt`: the AI SDK
+      // warns that a system message inside the prompt enables prompt
+      // injection, and providers are free to treat it as ordinary content.
+      system: system.map((content) => ({
+        role: 'system' as const,
+        content,
+      })),
       prompt: [
-        ...system.map(
-          (item): ModelMessage => ({
-            role: 'system',
-            content: item,
-          })
-        ),
         {
           role: 'user',
           content: `Create an agent configuration based on this request: \"${input.description}\".\n\nIMPORTANT: The following identifiers already exist and must NOT be used: ${existing.map((i) => i.name).join(', ')}\n  Return ONLY the JSON object, no other text, do not wrap in backticks`,

package/src/index.js

@@ -971,4 +971,9 @@ async function main() {
   }
 }
 
-main();
+// Awaited on purpose: everything the CLI does happens inside this promise, and
+// on Windows nothing else holds the process open while startup waits on async
+// filesystem I/O — the event loop drains and Bun exits 0 mid-run, so the CLI
+// prints its startup logs, never contacts the provider and reports success.
+// See: https://github.com/link-assistant/agent/issues/306
+await main();

package/src/project/instance.ts

@@ -58,6 +58,7 @@ export const Instance = {
   async dispose() {
     Log.Default.info('disposing instance', { directory: Instance.directory });
     await State.dispose(Instance.directory);
+    await Project.prune();
   },
   async disposeAll() {
     Log.Default.info('disposing all instances');

package/src/project/project.ts

@@ -4,9 +4,12 @@ import path from 'path';
 import { $ } from 'bun';
 import { Storage } from '../storage/storage';
 import { Log } from '../util/log';
+import fs from 'node:fs/promises';
+import { Global } from '../global';
 
 export namespace Project {
   const log = Log.create({ service: 'project' });
+  const recentSnapshotAge = 15 * 60_000;
   export const Info = z
     .object({
       id: z.string(),
@@ -24,6 +27,7 @@ export namespace Project {
 
   export async function fromDirectory(directory: string) {
     log.info(() => ({ message: 'fromDirectory', directory }));
+    await prune();
     const matches = Filesystem.up({ targets: ['.git'], start: directory });
     const git = await matches.next().then((x) => x.value);
     await matches.return();
@@ -101,4 +105,66 @@ export namespace Project {
     const keys = await Storage.list(['project']);
     return await Promise.all(keys.map((x) => Storage.read<Info>(x)));
   }
+
+  export async function prune() {
+    const root = path.join(Global.Path.data, 'snapshot');
+    const entries = await fs
+      .readdir(root, { withFileTypes: true })
+      .catch(() => []);
+    const snapshots: { id: string; path: string; modified: number }[] = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const snapshot = path.join(root, entry.name);
+      const modified = await fs
+        .stat(snapshot)
+        .then((stat) => stat.mtimeMs)
+        .catch(() => undefined);
+      if (modified === undefined) continue;
+      snapshots.push({ id: entry.name, path: snapshot, modified });
+    }
+    snapshots.sort((a, b) => b.modified - a.modified);
+
+    const newest = snapshots[0]?.id;
+    const recent = Date.now() - recentSnapshotAge;
+    for (const snapshot of snapshots) {
+      if (snapshot.id === newest || snapshot.modified >= recent) continue;
+      const project = await Storage.read<Info>(['project', snapshot.id]).catch(
+        () => undefined
+      );
+      const live = project
+        ? await fs
+            .stat(project.worktree)
+            .then((stat) => stat.isDirectory())
+            .catch(() => false)
+        : false;
+      if (live) continue;
+
+      await remove(snapshot).catch((error) =>
+        log.warn(() => ({
+          message: 'failed to prune snapshot',
+          projectID: snapshot.id,
+          error: error instanceof Error ? error.message : String(error),
+        }))
+      );
+    }
+  }
+
+  async function remove(snapshot: { id: string; path: string }) {
+    await fs.rm(snapshot.path, { recursive: true, force: true });
+    for (const session of await Storage.list(['session', snapshot.id])) {
+      const sessionID = session.at(-1)!;
+      for (const message of await Storage.list(['message', sessionID])) {
+        const messageID = message.at(-1)!;
+        for (const part of await Storage.list(['part', messageID])) {
+          await Storage.remove(part);
+        }
+        await Storage.remove(message);
+      }
+      await Storage.remove(['session_diff', sessionID]);
+      await Storage.remove(['todo', sessionID]);
+      await Storage.remove(session);
+    }
+    await Storage.remove(['project', snapshot.id]);
+    log.info(() => ({ message: 'pruned snapshot', projectID: snapshot.id }));
+  }
 }

package/src/session/processor.ts

@@ -508,9 +508,20 @@ export namespace SessionProcessor {
                     }
                     snapshot = undefined;
                   }
-                  SessionSummary.summarize({
+                  // Fire-and-forget on purpose, and guarded: a summarization
+                  // failure must not become an unhandled rejection that exits
+                  // the process while this stream is still being processed.
+                  // See: https://github.com/link-assistant/agent/issues/304
+                  void SessionSummary.summarize({
                     sessionID: input.sessionID,
                     messageID: input.assistantMessage.parentID,
+                  }).catch((error) => {
+                    log.warn(() => ({
+                      message: 'session summarization failed',
+                      sessionID: input.sessionID,
+                      error:
+                        error instanceof Error ? error.message : String(error),
+                    }));
                   });
                   break;
 

package/src/session/prompt.ts

@@ -833,9 +833,19 @@ export namespace SessionPrompt {
       };
 
       if (step === 1) {
-        SessionSummary.summarize({
+        // Fire-and-forget on purpose: the summary runs alongside the turn. The
+        // `void` marks that, and the `.catch` keeps a summarization failure
+        // from becoming an unhandled rejection that would exit the process and
+        // abort this turn. See: https://github.com/link-assistant/agent/issues/304
+        void SessionSummary.summarize({
           sessionID: sessionID,
           messageID: lastUser.id,
+        }).catch((error) => {
+          log.warn(() => ({
+            message: 'session summarization failed',
+            sessionID,
+            error: error instanceof Error ? error.message : String(error),
+          }));
         });
       }
 

package/src/session/summary.ts

@@ -2,7 +2,7 @@ import { Provider } from '../provider/provider';
 import { fn } from '../util/fn';
 import z from 'zod';
 import { Session } from '.';
-import { generateText, type ModelMessage } from 'ai';
+import { generateText } from 'ai';
 import { MessageV2 } from './message-v2';
 import { Identifier } from '../id/id';
 import { Snapshot } from '../snapshot';
@@ -25,11 +25,29 @@ export namespace SessionSummary {
       messageID: z.string(),
     }),
     async (input) => {
-      const all = await Session.messages({ sessionID: input.sessionID });
-      await Promise.all([
-        summarizeSession({ sessionID: input.sessionID, messages: all }),
-        summarizeMessage({ messageID: input.messageID, messages: all }),
-      ]);
+      // Summarization is a side quest: its whole product is a session title, a
+      // body and a diff stat, and it runs concurrently with the turn it
+      // describes. Neither caller awaits it, so a rejection escaping this
+      // function has no handler anywhere and becomes an `unhandledRejection`,
+      // which exits the process with status 1 and aborts the streaming turn.
+      // A failed title must never be a failed run.
+      // See: https://github.com/link-assistant/agent/issues/304
+      try {
+        const all = await Session.messages({ sessionID: input.sessionID });
+        await Promise.all([
+          summarizeSession({ sessionID: input.sessionID, messages: all }),
+          summarizeMessage({ messageID: input.messageID, messages: all }),
+        ]);
+      } catch (error) {
+        log.warn(() => ({
+          message: 'session summarization failed',
+          hint: 'The turn is unaffected; only the session summary is missing',
+          sessionID: input.sessionID,
+          messageID: input.messageID,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+        }));
+      }
     }
   );
 
@@ -187,13 +205,14 @@ export namespace SessionSummary {
           model.providerID,
           {}
         ),
+        // The system prompt belongs in `system`, not in `messages`: the AI SDK
+        // warns that a system message inside `messages` enables prompt
+        // injection, and providers are free to treat it as ordinary content.
+        system: systemPrompts.map((content) => ({
+          role: 'system' as const,
+          content,
+        })),
         messages: [
-          ...systemPrompts.map(
-            (x): ModelMessage => ({
-              role: 'system',
-              content: x,
-            })
-          ),
           {
             role: 'user' as const,
             content: userContent,
@@ -201,20 +220,34 @@ export namespace SessionSummary {
         ],
         headers: model.info.headers,
         model: model.language,
-      });
-
-      if (isVerbose()) {
-        log.info(() => ({
-          message: 'title API response received',
+      }).catch((err) => {
+        // A provider that resolves a model but errors on the request must cost
+        // the run its title, not its exit status.
+        // See: https://github.com/link-assistant/agent/issues/304
+        log.warn(() => ({
+          message: 'title API call failed',
           providerID: model.providerID,
           modelID: model.modelID,
-          titleLength: result.text.length,
-          usage: result.usage,
+          error: err instanceof Error ? err.message : String(err),
+          stack: err instanceof Error ? err.stack : undefined,
         }));
+        return undefined;
+      });
+
+      if (result) {
+        if (isVerbose()) {
+          log.info(() => ({
+            message: 'title API response received',
+            providerID: model.providerID,
+            modelID: model.modelID,
+            titleLength: result.text.length,
+            usage: result.usage,
+          }));
+        }
+        log.info(() => ({ message: 'title', title: result.text }));
+        userMsg.summary.title = result.text;
+        await Session.updateMessage(userMsg);
       }
-      log.info(() => ({ message: 'title', title: result.text }));
-      userMsg.summary.title = result.text;
-      await Session.updateMessage(userMsg);
     }
 
     if (

package/src/snapshot/index.ts

@@ -30,6 +30,25 @@ export namespace Snapshot {
         .nothrow();
       log.info(() => ({ message: 'initialized' }));
     }
+    const objects =
+      await $`git rev-parse --path-format=absolute --git-path objects`
+        .quiet()
+        .cwd(Instance.worktree)
+        .nothrow();
+    if (objects.exitCode === 0) {
+      const info = path.join(git, 'objects', 'info');
+      await fs.mkdir(info, { recursive: true });
+      await fs.writeFile(
+        path.join(info, 'alternates'),
+        `${objects.text().trim()}\n`
+      );
+    } else {
+      log.warn(() => ({
+        message: 'failed to resolve repository objects',
+        exitCode: objects.exitCode,
+        stderr: objects.stderr.toString(),
+      }));
+    }
     await $`git --git-dir ${git} --work-tree ${Instance.worktree} add .`
       .quiet()
       .cwd(Instance.directory)