@link-assistant/agent 0.0.8 → 0.0.11

package/src/global/index.ts

@@ -1,25 +1,25 @@
-import fs from "fs/promises"
-import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir"
-import path from "path"
-import os from "os"
+import fs from 'fs/promises';
+import { xdgData, xdgCache, xdgConfig, xdgState } from 'xdg-basedir';
+import path from 'path';
+import os from 'os';
 
-const app = "opencode"
+const app = 'opencode';
 
-const data = path.join(xdgData!, app)
-const cache = path.join(xdgCache!, app)
-const config = path.join(xdgConfig!, app)
-const state = path.join(xdgState!, app)
+const data = path.join(xdgData!, app);
+const cache = path.join(xdgCache!, app);
+const config = path.join(xdgConfig!, app);
+const state = path.join(xdgState!, app);
 
 export namespace Global {
   export const Path = {
     home: os.homedir(),
     data,
-    bin: path.join(data, "bin"),
-    log: path.join(data, "log"),
+    bin: path.join(data, 'bin'),
+    log: path.join(data, 'log'),
     cache,
     config,
     state,
-  } as const
+  } as const;
 }
 
 await Promise.all([
@@ -28,25 +28,25 @@ await Promise.all([
   fs.mkdir(Global.Path.state, { recursive: true }),
   fs.mkdir(Global.Path.log, { recursive: true }),
   fs.mkdir(Global.Path.bin, { recursive: true }),
-])
+]);
 
-const CACHE_VERSION = "9"
+const CACHE_VERSION = '9';
 
-const version = await Bun.file(path.join(Global.Path.cache, "version"))
+const version = await Bun.file(path.join(Global.Path.cache, 'version'))
   .text()
-  .catch(() => "0")
+  .catch(() => '0');
 
 if (version !== CACHE_VERSION) {
   try {
-    const contents = await fs.readdir(Global.Path.cache)
+    const contents = await fs.readdir(Global.Path.cache);
     await Promise.all(
       contents.map((item) =>
         fs.rm(path.join(Global.Path.cache, item), {
           recursive: true,
           force: true,
-        }),
-      ),
-    )
+        })
+      )
+    );
   } catch (e) {}
-  await Bun.file(path.join(Global.Path.cache, "version")).write(CACHE_VERSION)
+  await Bun.file(path.join(Global.Path.cache, 'version')).write(CACHE_VERSION);
 }

package/src/id/id.ts

@@ -1,72 +1,86 @@
-import z from "zod"
-import { randomBytes } from "crypto"
+import z from 'zod';
+import { randomBytes } from 'crypto';
 
 export namespace Identifier {
   const prefixes = {
-    session: "ses",
-    message: "msg",
-    permission: "per",
-    user: "usr",
-    part: "prt",
-  } as const
+    session: 'ses',
+    message: 'msg',
+    permission: 'per',
+    user: 'usr',
+    part: 'prt',
+  } as const;
 
   export function schema(prefix: keyof typeof prefixes) {
-    return z.string().startsWith(prefixes[prefix])
+    return z.string().startsWith(prefixes[prefix]);
   }
 
-  const LENGTH = 26
+  const LENGTH = 26;
 
   // State for monotonic ID generation
-  let lastTimestamp = 0
-  let counter = 0
+  let lastTimestamp = 0;
+  let counter = 0;
 
   export function ascending(prefix: keyof typeof prefixes, given?: string) {
-    return generateID(prefix, false, given)
+    return generateID(prefix, false, given);
   }
 
   export function descending(prefix: keyof typeof prefixes, given?: string) {
-    return generateID(prefix, true, given)
+    return generateID(prefix, true, given);
   }
 
-  function generateID(prefix: keyof typeof prefixes, descending: boolean, given?: string): string {
+  function generateID(
+    prefix: keyof typeof prefixes,
+    descending: boolean,
+    given?: string
+  ): string {
     if (!given) {
-      return create(prefix, descending)
+      return create(prefix, descending);
     }
 
     if (!given.startsWith(prefixes[prefix])) {
-      throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`)
+      throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`);
     }
-    return given
+    return given;
   }
 
   function randomBase62(length: number): string {
-    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-    let result = ""
-    const bytes = randomBytes(length)
+    const chars =
+      '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+    let result = '';
+    const bytes = randomBytes(length);
     for (let i = 0; i < length; i++) {
-      result += chars[bytes[i] % 62]
+      result += chars[bytes[i] % 62];
     }
-    return result
+    return result;
   }
 
-  export function create(prefix: keyof typeof prefixes, descending: boolean, timestamp?: number): string {
-    const currentTimestamp = timestamp ?? Date.now()
+  export function create(
+    prefix: keyof typeof prefixes,
+    descending: boolean,
+    timestamp?: number
+  ): string {
+    const currentTimestamp = timestamp ?? Date.now();
 
     if (currentTimestamp !== lastTimestamp) {
-      lastTimestamp = currentTimestamp
-      counter = 0
+      lastTimestamp = currentTimestamp;
+      counter = 0;
     }
-    counter++
+    counter++;
 
-    let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
+    let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter);
 
-    now = descending ? ~now : now
+    now = descending ? ~now : now;
 
-    const timeBytes = Buffer.alloc(6)
+    const timeBytes = Buffer.alloc(6);
     for (let i = 0; i < 6; i++) {
-      timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
+      timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff));
     }
 
-    return prefixes[prefix] + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12)
+    return (
+      prefixes[prefix] +
+      '_' +
+      timeBytes.toString('hex') +
+      randomBase62(LENGTH - 12)
+    );
   }
 }