@link-assistant/agent 0.0.9 → 0.0.12

package/src/session/system.ts

@@ -1,138 +1,152 @@
-import { Ripgrep } from "../file/ripgrep"
-import { Global } from "../global"
-import { Filesystem } from "../util/filesystem"
-import { Config } from "../config/config"
+import { Ripgrep } from '../file/ripgrep';
+import { Global } from '../global';
+import { Filesystem } from '../util/filesystem';
+import { Config } from '../config/config';
 
-import { Instance } from "../project/instance"
-import path from "path"
-import os from "os"
+import { Instance } from '../project/instance';
+import path from 'path';
+import os from 'os';
 
-import PROMPT_ANTHROPIC from "./prompt/anthropic.txt"
-import PROMPT_ANTHROPIC_WITHOUT_TODO from "./prompt/qwen.txt"
-import PROMPT_POLARIS from "./prompt/polaris.txt"
-import PROMPT_BEAST from "./prompt/beast.txt"
-import PROMPT_GEMINI from "./prompt/gemini.txt"
-import PROMPT_ANTHROPIC_SPOOF from "./prompt/anthropic_spoof.txt"
-import PROMPT_SUMMARIZE from "./prompt/summarize.txt"
-import PROMPT_TITLE from "./prompt/title.txt"
-import PROMPT_CODEX from "./prompt/codex.txt"
-import PROMPT_GROK_CODE from "./prompt/grok-code.txt"
+import PROMPT_ANTHROPIC from './prompt/anthropic.txt';
+import PROMPT_ANTHROPIC_WITHOUT_TODO from './prompt/qwen.txt';
+import PROMPT_POLARIS from './prompt/polaris.txt';
+import PROMPT_BEAST from './prompt/beast.txt';
+import PROMPT_GEMINI from './prompt/gemini.txt';
+import PROMPT_ANTHROPIC_SPOOF from './prompt/anthropic_spoof.txt';
+import PROMPT_SUMMARIZE from './prompt/summarize.txt';
+import PROMPT_TITLE from './prompt/title.txt';
+import PROMPT_CODEX from './prompt/codex.txt';
+import PROMPT_GROK_CODE from './prompt/grok-code.txt';
 
 export namespace SystemPrompt {
   export function header(providerID: string) {
-    if (providerID.includes("anthropic")) return [PROMPT_ANTHROPIC_SPOOF.trim()]
-    return []
+    if (providerID.includes('anthropic'))
+      return [PROMPT_ANTHROPIC_SPOOF.trim()];
+    return [];
   }
 
   export function provider(modelID: string) {
-    if (modelID.includes("gpt-5")) return [PROMPT_CODEX]
-    if (modelID.includes("gpt-") || modelID.includes("o1") || modelID.includes("o3")) return [PROMPT_BEAST]
-    if (modelID.includes("gemini-")) return [PROMPT_GEMINI]
-    if (modelID.includes("claude")) return [PROMPT_ANTHROPIC]
-    if (modelID.includes("polaris-alpha")) return [PROMPT_POLARIS]
-    if (modelID.includes("grok-code")) return [PROMPT_GROK_CODE]
-    return [PROMPT_ANTHROPIC_WITHOUT_TODO]
+    if (modelID.includes('gpt-5')) return [PROMPT_CODEX];
+    if (
+      modelID.includes('gpt-') ||
+      modelID.includes('o1') ||
+      modelID.includes('o3')
+    )
+      return [PROMPT_BEAST];
+    if (modelID.includes('gemini-')) return [PROMPT_GEMINI];
+    if (modelID.includes('claude')) return [PROMPT_ANTHROPIC];
+    if (modelID.includes('polaris-alpha')) return [PROMPT_POLARIS];
+    if (modelID.includes('grok-code')) return [PROMPT_GROK_CODE];
+    return [PROMPT_ANTHROPIC_WITHOUT_TODO];
   }
 
   export async function environment() {
-    const project = Instance.project
+    const project = Instance.project;
     return [
       [
         `Here is some useful information about the environment you are running in:`,
         `<env>`,
         `  Working directory: ${Instance.directory}`,
-        `  Is directory a git repo: ${project.vcs === "git" ? "yes" : "no"}`,
+        `  Is directory a git repo: ${project.vcs === 'git' ? 'yes' : 'no'}`,
         `  Platform: ${process.platform}`,
         `  Today's date: ${new Date().toDateString()}`,
         `</env>`,
         `<files>`,
         `  ${
-          project.vcs === "git"
+          project.vcs === 'git'
             ? await Ripgrep.tree({
                 cwd: Instance.directory,
                 limit: 200,
               })
-            : ""
+            : ''
         }`,
         `</files>`,
-      ].join("\n"),
-    ]
+      ].join('\n'),
+    ];
   }
 
   const LOCAL_RULE_FILES = [
-    "AGENTS.md",
-    "CLAUDE.md",
-    "CONTEXT.md", // deprecated
-  ]
+    'AGENTS.md',
+    'CLAUDE.md',
+    'CONTEXT.md', // deprecated
+  ];
   const GLOBAL_RULE_FILES = [
-    path.join(Global.Path.config, "AGENTS.md"),
-    path.join(os.homedir(), ".claude", "CLAUDE.md"),
-  ]
+    path.join(Global.Path.config, 'AGENTS.md'),
+    path.join(os.homedir(), '.claude', 'CLAUDE.md'),
+  ];
 
   export async function custom() {
-    const config = await Config.get()
-    const paths = new Set<string>()
+    const config = await Config.get();
+    const paths = new Set<string>();
 
     for (const localRuleFile of LOCAL_RULE_FILES) {
-      const matches = await Filesystem.findUp(localRuleFile, Instance.directory, Instance.worktree)
+      const matches = await Filesystem.findUp(
+        localRuleFile,
+        Instance.directory,
+        Instance.worktree
+      );
       if (matches.length > 0) {
-        matches.forEach((path) => paths.add(path))
-        break
+        matches.forEach((path) => paths.add(path));
+        break;
       }
     }
 
     for (const globalRuleFile of GLOBAL_RULE_FILES) {
       if (await Bun.file(globalRuleFile).exists()) {
-        paths.add(globalRuleFile)
-        break
+        paths.add(globalRuleFile);
+        break;
       }
     }
 
     if (config.instructions) {
       for (let instruction of config.instructions) {
-        if (instruction.startsWith("~/")) {
-          instruction = path.join(os.homedir(), instruction.slice(2))
+        if (instruction.startsWith('~/')) {
+          instruction = path.join(os.homedir(), instruction.slice(2));
         }
-        let matches: string[] = []
+        let matches: string[] = [];
         if (path.isAbsolute(instruction)) {
           matches = await Array.fromAsync(
             new Bun.Glob(path.basename(instruction)).scan({
               cwd: path.dirname(instruction),
               absolute: true,
               onlyFiles: true,
-            }),
-          ).catch(() => [])
+            })
+          ).catch(() => []);
         } else {
-          matches = await Filesystem.globUp(instruction, Instance.directory, Instance.worktree).catch(() => [])
+          matches = await Filesystem.globUp(
+            instruction,
+            Instance.directory,
+            Instance.worktree
+          ).catch(() => []);
         }
-        matches.forEach((path) => paths.add(path))
+        matches.forEach((path) => paths.add(path));
       }
     }
 
     const found = Array.from(paths).map((p) =>
       Bun.file(p)
         .text()
-        .catch(() => "")
-        .then((x) => "Instructions from: " + p + "\n" + x),
-    )
-    return Promise.all(found).then((result) => result.filter(Boolean))
+        .catch(() => '')
+        .then((x) => 'Instructions from: ' + p + '\n' + x)
+    );
+    return Promise.all(found).then((result) => result.filter(Boolean));
   }
 
   export function summarize(providerID: string) {
     switch (providerID) {
-      case "anthropic":
-        return [PROMPT_ANTHROPIC_SPOOF.trim(), PROMPT_SUMMARIZE]
+      case 'anthropic':
+        return [PROMPT_ANTHROPIC_SPOOF.trim(), PROMPT_SUMMARIZE];
       default:
-        return [PROMPT_SUMMARIZE]
+        return [PROMPT_SUMMARIZE];
     }
   }
 
   export function title(providerID: string) {
     switch (providerID) {
-      case "anthropic":
-        return [PROMPT_ANTHROPIC_SPOOF.trim(), PROMPT_TITLE]
+      case 'anthropic':
+        return [PROMPT_ANTHROPIC_SPOOF.trim(), PROMPT_TITLE];
       default:
-        return [PROMPT_TITLE]
+        return [PROMPT_TITLE];
     }
   }
 }

package/src/session/todo.ts

@@ -1,36 +1,42 @@
-import z from "zod"
-import { Bus } from "../bus"
-import { Storage } from "../storage/storage"
+import z from 'zod';
+import { Bus } from '../bus';
+import { Storage } from '../storage/storage';
 
 export namespace Todo {
   export const Info = z
     .object({
-      content: z.string().describe("Brief description of the task"),
-      status: z.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
-      priority: z.string().describe("Priority level of the task: high, medium, low"),
-      id: z.string().describe("Unique identifier for the todo item"),
+      content: z.string().describe('Brief description of the task'),
+      status: z
+        .string()
+        .describe(
+          'Current status of the task: pending, in_progress, completed, cancelled'
+        ),
+      priority: z
+        .string()
+        .describe('Priority level of the task: high, medium, low'),
+      id: z.string().describe('Unique identifier for the todo item'),
     })
-    .meta({ ref: "Todo" })
-  export type Info = z.infer<typeof Info>
+    .meta({ ref: 'Todo' });
+  export type Info = z.infer<typeof Info>;
 
   export const Event = {
     Updated: Bus.event(
-      "todo.updated",
+      'todo.updated',
       z.object({
         sessionID: z.string(),
         todos: z.array(Info),
-      }),
+      })
     ),
-  }
+  };
 
   export async function update(input: { sessionID: string; todos: Info[] }) {
-    await Storage.write(["todo", input.sessionID], input.todos)
-    Bus.publish(Event.Updated, input)
+    await Storage.write(['todo', input.sessionID], input.todos);
+    Bus.publish(Event.Updated, input);
   }
 
   export async function get(sessionID: string) {
-    return Storage.read<Info[]>(["todo", sessionID])
+    return Storage.read<Info[]>(['todo', sessionID])
       .then((x) => x || [])
-      .catch(() => [])
+      .catch(() => []);
   }
 }

package/src/snapshot/index.ts

@@ -1,20 +1,20 @@
-import { $ } from "bun"
-import path from "path"
-import fs from "fs/promises"
-import { Log } from "../util/log"
-import { Global } from "../global"
-import z from "zod"
-import { Config } from "../config/config"
-import { Instance } from "../project/instance"
+import { $ } from 'bun';
+import path from 'path';
+import fs from 'fs/promises';
+import { Log } from '../util/log';
+import { Global } from '../global';
+import z from 'zod';
+import { Config } from '../config/config';
+import { Instance } from '../project/instance';
 
 export namespace Snapshot {
-  const log = Log.create({ service: "snapshot" })
+  const log = Log.create({ service: 'snapshot' });
 
   export async function track() {
-    if (Instance.project.vcs !== "git") return
-    const cfg = await Config.get()
-    if (cfg.snapshot === false) return
-    const git = gitdir()
+    if (Instance.project.vcs !== 'git') return;
+    const cfg = await Config.get();
+    if (cfg.snapshot === false) return;
+    const git = gitdir();
     if (await fs.mkdir(git, { recursive: true })) {
       await $`git init`
         .env({
@@ -23,125 +23,138 @@ export namespace Snapshot {
           GIT_WORK_TREE: Instance.worktree,
         })
         .quiet()
-        .nothrow()
+        .nothrow();
       // Configure git to not convert line endings on Windows
-      await $`git --git-dir ${git} config core.autocrlf false`.quiet().nothrow()
-      log.info("initialized")
+      await $`git --git-dir ${git} config core.autocrlf false`
+        .quiet()
+        .nothrow();
+      log.info('initialized');
     }
-    await $`git --git-dir ${git} --work-tree ${Instance.worktree} add .`.quiet().cwd(Instance.directory).nothrow()
-    const hash = await $`git --git-dir ${git} --work-tree ${Instance.worktree} write-tree`
+    await $`git --git-dir ${git} --work-tree ${Instance.worktree} add .`
       .quiet()
       .cwd(Instance.directory)
-      .nothrow()
-      .text()
-    log.info("tracking", { hash, cwd: Instance.directory, git })
-    return hash.trim()
+      .nothrow();
+    const hash =
+      await $`git --git-dir ${git} --work-tree ${Instance.worktree} write-tree`
+        .quiet()
+        .cwd(Instance.directory)
+        .nothrow()
+        .text();
+    log.info('tracking', { hash, cwd: Instance.directory, git });
+    return hash.trim();
   }
 
   export const Patch = z.object({
     hash: z.string(),
     files: z.string().array(),
-  })
-  export type Patch = z.infer<typeof Patch>
+  });
+  export type Patch = z.infer<typeof Patch>;
 
   export async function patch(hash: string): Promise<Patch> {
-    const git = gitdir()
-    await $`git --git-dir ${git} --work-tree ${Instance.worktree} add .`.quiet().cwd(Instance.directory).nothrow()
+    const git = gitdir();
+    await $`git --git-dir ${git} --work-tree ${Instance.worktree} add .`
+      .quiet()
+      .cwd(Instance.directory)
+      .nothrow();
     const result =
       await $`git -c core.autocrlf=false --git-dir ${git} --work-tree ${Instance.worktree} diff --name-only ${hash} -- .`
         .quiet()
         .cwd(Instance.directory)
-        .nothrow()
+        .nothrow();
 
     // If git diff fails, return empty patch
     if (result.exitCode !== 0) {
-      log.warn("failed to get diff", { hash, exitCode: result.exitCode })
-      return { hash, files: [] }
+      log.warn('failed to get diff', { hash, exitCode: result.exitCode });
+      return { hash, files: [] };
     }
 
-    const files = result.text()
+    const files = result.text();
     return {
       hash,
       files: files
         .trim()
-        .split("\n")
+        .split('\n')
         .map((x) => x.trim())
         .filter(Boolean)
         .map((x) => path.join(Instance.worktree, x)),
-    }
+    };
   }
 
   export async function restore(snapshot: string) {
-    log.info("restore", { commit: snapshot })
-    const git = gitdir()
+    log.info('restore', { commit: snapshot });
+    const git = gitdir();
     const result =
       await $`git --git-dir ${git} --work-tree ${Instance.worktree} read-tree ${snapshot} && git --git-dir ${git} --work-tree ${Instance.worktree} checkout-index -a -f`
         .quiet()
         .cwd(Instance.worktree)
-        .nothrow()
+        .nothrow();
 
     if (result.exitCode !== 0) {
-      log.error("failed to restore snapshot", {
+      log.error('failed to restore snapshot', {
         snapshot,
         exitCode: result.exitCode,
         stderr: result.stderr.toString(),
         stdout: result.stdout.toString(),
-      })
+      });
     }
   }
 
   export async function revert(patches: Patch[]) {
-    const files = new Set<string>()
-    const git = gitdir()
+    const files = new Set<string>();
+    const git = gitdir();
     for (const item of patches) {
       for (const file of item.files) {
-        if (files.has(file)) continue
-        log.info("reverting", { file, hash: item.hash })
-        const result = await $`git --git-dir ${git} --work-tree ${Instance.worktree} checkout ${item.hash} -- ${file}`
-          .quiet()
-          .cwd(Instance.worktree)
-          .nothrow()
+        if (files.has(file)) continue;
+        log.info('reverting', { file, hash: item.hash });
+        const result =
+          await $`git --git-dir ${git} --work-tree ${Instance.worktree} checkout ${item.hash} -- ${file}`
+            .quiet()
+            .cwd(Instance.worktree)
+            .nothrow();
         if (result.exitCode !== 0) {
-          const relativePath = path.relative(Instance.worktree, file)
+          const relativePath = path.relative(Instance.worktree, file);
           const checkTree =
             await $`git --git-dir ${git} --work-tree ${Instance.worktree} ls-tree ${item.hash} -- ${relativePath}`
               .quiet()
               .cwd(Instance.worktree)
-              .nothrow()
+              .nothrow();
           if (checkTree.exitCode === 0 && checkTree.text().trim()) {
-            log.info("file existed in snapshot but checkout failed, keeping", {
+            log.info('file existed in snapshot but checkout failed, keeping', {
               file,
-            })
+            });
           } else {
-            log.info("file did not exist in snapshot, deleting", { file })
-            await fs.unlink(file).catch(() => {})
+            log.info('file did not exist in snapshot, deleting', { file });
+            await fs.unlink(file).catch(() => {});
           }
         }
-        files.add(file)
+        files.add(file);
       }
     }
   }
 
   export async function diff(hash: string) {
-    const git = gitdir()
-    await $`git --git-dir ${git} --work-tree ${Instance.worktree} add .`.quiet().cwd(Instance.directory).nothrow()
+    const git = gitdir();
+    await $`git --git-dir ${git} --work-tree ${Instance.worktree} add .`
+      .quiet()
+      .cwd(Instance.directory)
+      .nothrow();
     const result =
       await $`git -c core.autocrlf=false --git-dir ${git} --work-tree ${Instance.worktree} diff ${hash} -- .`
         .quiet()
         .cwd(Instance.worktree)
-        .nothrow()
+        .nothrow();
 
     if (result.exitCode !== 0) {
-      log.warn("failed to get diff", {
+      log.warn('failed to get diff', {
         hash,
         exitCode: result.exitCode,
         stderr: result.stderr.toString(),
         stdout: result.stdout.toString(),
-      })
-      return ""
+      });
+      return '';
     }
 
-    return result.text().trim()
+    return result.text().trim();
   }
 
   export const FileDiff = z
@@ -153,45 +166,48 @@ export namespace Snapshot {
       deletions: z.number(),
     })
     .meta({
-      ref: "FileDiff",
-    })
-  export type FileDiff = z.infer<typeof FileDiff>
-  export async function diffFull(from: string, to: string): Promise<FileDiff[]> {
-    const git = gitdir()
-    const result: FileDiff[] = []
+      ref: 'FileDiff',
+    });
+  export type FileDiff = z.infer<typeof FileDiff>;
+  export async function diffFull(
+    from: string,
+    to: string
+  ): Promise<FileDiff[]> {
+    const git = gitdir();
+    const result: FileDiff[] = [];
     for await (const line of $`git -c core.autocrlf=false --git-dir ${git} --work-tree ${Instance.worktree} diff --no-renames --numstat ${from} ${to} -- .`
       .quiet()
       .cwd(Instance.directory)
       .nothrow()
       .lines()) {
-      if (!line) continue
-      const [additions, deletions, file] = line.split("\t")
-      const isBinaryFile = additions === "-" && deletions === "-"
+      if (!line) continue;
+      const [additions, deletions, file] = line.split('\t');
+      const isBinaryFile = additions === '-' && deletions === '-';
       const before = isBinaryFile
-        ? ""
+        ? ''
         : await $`git -c core.autocrlf=false --git-dir ${git} --work-tree ${Instance.worktree} show ${from}:${file}`
             .quiet()
             .nothrow()
-            .text()
+            .text();
       const after = isBinaryFile
-        ? ""
+        ? ''
         : await $`git -c core.autocrlf=false --git-dir ${git} --work-tree ${Instance.worktree} show ${to}:${file}`
             .quiet()
             .nothrow()
-            .text()
+            .text();
       result.push({
         file,
         before,
         after,
         additions: parseInt(additions),
         deletions: parseInt(deletions),
-      })
+      });
     }
-    return result
+    return result;
   }
 
   function gitdir() {
-    const project = Instance.project
-    return path.join(Global.Path.data, "snapshot", project.id)
+    const project = Instance.project;
+    return path.join(Global.Path.data, 'snapshot', project.id);
   }
 }