@link-assistant/agent 0.0.9 → 0.0.12

package/src/format/formatter.ts

@@ -1,248 +1,292 @@
-import { readableStreamToText } from "bun"
-import { BunProc } from "../bun"
-import { Instance } from "../project/instance"
-import { Filesystem } from "../util/filesystem"
+import { readableStreamToText } from 'bun';
+import { BunProc } from '../bun';
+import { Instance } from '../project/instance';
+import { Filesystem } from '../util/filesystem';
 
 export interface Info {
-  name: string
-  command: string[]
-  environment?: Record<string, string>
-  extensions: string[]
-  enabled(): Promise<boolean>
+  name: string;
+  command: string[];
+  environment?: Record<string, string>;
+  extensions: string[];
+  enabled(): Promise<boolean>;
 }
 
 export const gofmt: Info = {
-  name: "gofmt",
-  command: ["gofmt", "-w", "$FILE"],
-  extensions: [".go"],
+  name: 'gofmt',
+  command: ['gofmt', '-w', '$FILE'],
+  extensions: ['.go'],
   async enabled() {
-    return Bun.which("gofmt") !== null
+    return Bun.which('gofmt') !== null;
   },
-}
+};
 
 export const mix: Info = {
-  name: "mix",
-  command: ["mix", "format", "$FILE"],
-  extensions: [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"],
+  name: 'mix',
+  command: ['mix', 'format', '$FILE'],
+  extensions: ['.ex', '.exs', '.eex', '.heex', '.leex', '.neex', '.sface'],
   async enabled() {
-    return Bun.which("mix") !== null
+    return Bun.which('mix') !== null;
   },
-}
+};
 
 export const prettier: Info = {
-  name: "prettier",
-  command: [BunProc.which(), "x", "prettier", "--write", "$FILE"],
+  name: 'prettier',
+  command: [BunProc.which(), 'x', 'prettier', '--write', '$FILE'],
   environment: {
-    BUN_BE_BUN: "1",
+    BUN_BE_BUN: '1',
   },
   extensions: [
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".html",
-    ".htm",
-    ".css",
-    ".scss",
-    ".sass",
-    ".less",
-    ".vue",
-    ".svelte",
-    ".json",
-    ".jsonc",
-    ".yaml",
-    ".yml",
-    ".toml",
-    ".xml",
-    ".md",
-    ".mdx",
-    ".graphql",
-    ".gql",
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.ts',
+    '.tsx',
+    '.mts',
+    '.cts',
+    '.html',
+    '.htm',
+    '.css',
+    '.scss',
+    '.sass',
+    '.less',
+    '.vue',
+    '.svelte',
+    '.json',
+    '.jsonc',
+    '.yaml',
+    '.yml',
+    '.toml',
+    '.xml',
+    '.md',
+    '.mdx',
+    '.graphql',
+    '.gql',
   ],
   async enabled() {
-    const items = await Filesystem.findUp("package.json", Instance.directory, Instance.worktree)
+    const items = await Filesystem.findUp(
+      'package.json',
+      Instance.directory,
+      Instance.worktree
+    );
     for (const item of items) {
-      const json = await Bun.file(item).json()
-      if (json.dependencies?.prettier) return true
-      if (json.devDependencies?.prettier) return true
+      const json = await Bun.file(item).json();
+      if (json.dependencies?.prettier) return true;
+      if (json.devDependencies?.prettier) return true;
     }
-    return false
+    return false;
   },
-}
+};
 
 export const biome: Info = {
-  name: "biome",
-  command: [BunProc.which(), "x", "@biomejs/biome", "format", "--write", "$FILE"],
+  name: 'biome',
+  command: [
+    BunProc.which(),
+    'x',
+    '@biomejs/biome',
+    'format',
+    '--write',
+    '$FILE',
+  ],
   environment: {
-    BUN_BE_BUN: "1",
+    BUN_BE_BUN: '1',
   },
   extensions: [
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".html",
-    ".htm",
-    ".css",
-    ".scss",
-    ".sass",
-    ".less",
-    ".vue",
-    ".svelte",
-    ".json",
-    ".jsonc",
-    ".yaml",
-    ".yml",
-    ".toml",
-    ".xml",
-    ".md",
-    ".mdx",
-    ".graphql",
-    ".gql",
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.ts',
+    '.tsx',
+    '.mts',
+    '.cts',
+    '.html',
+    '.htm',
+    '.css',
+    '.scss',
+    '.sass',
+    '.less',
+    '.vue',
+    '.svelte',
+    '.json',
+    '.jsonc',
+    '.yaml',
+    '.yml',
+    '.toml',
+    '.xml',
+    '.md',
+    '.mdx',
+    '.graphql',
+    '.gql',
   ],
   async enabled() {
-    const configs = ["biome.json", "biome.jsonc"]
+    const configs = ['biome.json', 'biome.jsonc'];
     for (const config of configs) {
-      const found = await Filesystem.findUp(config, Instance.directory, Instance.worktree)
+      const found = await Filesystem.findUp(
+        config,
+        Instance.directory,
+        Instance.worktree
+      );
       if (found.length > 0) {
-        return true
+        return true;
       }
     }
-    return false
+    return false;
   },
-}
+};
 
 export const zig: Info = {
-  name: "zig",
-  command: ["zig", "fmt", "$FILE"],
-  extensions: [".zig", ".zon"],
+  name: 'zig',
+  command: ['zig', 'fmt', '$FILE'],
+  extensions: ['.zig', '.zon'],
   async enabled() {
-    return Bun.which("zig") !== null
+    return Bun.which('zig') !== null;
   },
-}
+};
 
 export const clang: Info = {
-  name: "clang-format",
-  command: ["clang-format", "-i", "$FILE"],
-  extensions: [".c", ".cc", ".cpp", ".cxx", ".c++", ".h", ".hh", ".hpp", ".hxx", ".h++", ".ino", ".C", ".H"],
+  name: 'clang-format',
+  command: ['clang-format', '-i', '$FILE'],
+  extensions: [
+    '.c',
+    '.cc',
+    '.cpp',
+    '.cxx',
+    '.c++',
+    '.h',
+    '.hh',
+    '.hpp',
+    '.hxx',
+    '.h++',
+    '.ino',
+    '.C',
+    '.H',
+  ],
   async enabled() {
-    const items = await Filesystem.findUp(".clang-format", Instance.directory, Instance.worktree)
-    return items.length > 0
+    const items = await Filesystem.findUp(
+      '.clang-format',
+      Instance.directory,
+      Instance.worktree
+    );
+    return items.length > 0;
   },
-}
+};
 
 export const ktlint: Info = {
-  name: "ktlint",
-  command: ["ktlint", "-F", "$FILE"],
-  extensions: [".kt", ".kts"],
+  name: 'ktlint',
+  command: ['ktlint', '-F', '$FILE'],
+  extensions: ['.kt', '.kts'],
   async enabled() {
-    return Bun.which("ktlint") !== null
+    return Bun.which('ktlint') !== null;
   },
-}
+};
 
 export const ruff: Info = {
-  name: "ruff",
-  command: ["ruff", "format", "$FILE"],
-  extensions: [".py", ".pyi"],
+  name: 'ruff',
+  command: ['ruff', 'format', '$FILE'],
+  extensions: ['.py', '.pyi'],
   async enabled() {
-    if (!Bun.which("ruff")) return false
-    const configs = ["pyproject.toml", "ruff.toml", ".ruff.toml"]
+    if (!Bun.which('ruff')) return false;
+    const configs = ['pyproject.toml', 'ruff.toml', '.ruff.toml'];
     for (const config of configs) {
-      const found = await Filesystem.findUp(config, Instance.directory, Instance.worktree)
+      const found = await Filesystem.findUp(
+        config,
+        Instance.directory,
+        Instance.worktree
+      );
       if (found.length > 0) {
-        if (config === "pyproject.toml") {
-          const content = await Bun.file(found[0]).text()
-          if (content.includes("[tool.ruff]")) return true
+        if (config === 'pyproject.toml') {
+          const content = await Bun.file(found[0]).text();
+          if (content.includes('[tool.ruff]')) return true;
         } else {
-          return true
+          return true;
         }
       }
     }
-    const deps = ["requirements.txt", "pyproject.toml", "Pipfile"]
+    const deps = ['requirements.txt', 'pyproject.toml', 'Pipfile'];
     for (const dep of deps) {
-      const found = await Filesystem.findUp(dep, Instance.directory, Instance.worktree)
+      const found = await Filesystem.findUp(
+        dep,
+        Instance.directory,
+        Instance.worktree
+      );
       if (found.length > 0) {
-        const content = await Bun.file(found[0]).text()
-        if (content.includes("ruff")) return true
+        const content = await Bun.file(found[0]).text();
+        if (content.includes('ruff')) return true;
       }
     }
-    return false
+    return false;
   },
-}
+};
 
 export const rlang: Info = {
-  name: "air",
-  command: ["air", "format", "$FILE"],
-  extensions: [".R"],
+  name: 'air',
+  command: ['air', 'format', '$FILE'],
+  extensions: ['.R'],
   async enabled() {
-    const airPath = Bun.which("air")
-    if (airPath == null) return false
+    const airPath = Bun.which('air');
+    if (airPath == null) return false;
 
     try {
-      const proc = Bun.spawn(["air", "--help"], {
-        stdout: "pipe",
-        stderr: "pipe",
-      })
-      await proc.exited
-      const output = await readableStreamToText(proc.stdout)
+      const proc = Bun.spawn(['air', '--help'], {
+        stdout: 'pipe',
+        stderr: 'pipe',
+      });
+      await proc.exited;
+      const output = await readableStreamToText(proc.stdout);
 
       // Check for "Air: An R language server and formatter"
-      const firstLine = output.split("\n")[0]
-      const hasR = firstLine.includes("R language")
-      const hasFormatter = firstLine.includes("formatter")
-      return hasR && hasFormatter
+      const firstLine = output.split('\n')[0];
+      const hasR = firstLine.includes('R language');
+      const hasFormatter = firstLine.includes('formatter');
+      return hasR && hasFormatter;
     } catch (error) {
-      return false
+      return false;
     }
   },
-}
+};
 
 export const uvformat: Info = {
-  name: "uv format",
-  command: ["uv", "format", "--", "$FILE"],
-  extensions: [".py", ".pyi"],
+  name: 'uv format',
+  command: ['uv', 'format', '--', '$FILE'],
+  extensions: ['.py', '.pyi'],
   async enabled() {
-    if (await ruff.enabled()) return false
-    if (Bun.which("uv") !== null) {
-      const proc = Bun.spawn(["uv", "format", "--help"], { stderr: "pipe", stdout: "pipe" })
-      const code = await proc.exited
-      return code === 0
+    if (await ruff.enabled()) return false;
+    if (Bun.which('uv') !== null) {
+      const proc = Bun.spawn(['uv', 'format', '--help'], {
+        stderr: 'pipe',
+        stdout: 'pipe',
+      });
+      const code = await proc.exited;
+      return code === 0;
     }
-    return false
+    return false;
   },
-}
+};
 
 export const rubocop: Info = {
-  name: "rubocop",
-  command: ["rubocop", "--autocorrect", "$FILE"],
-  extensions: [".rb", ".rake", ".gemspec", ".ru"],
+  name: 'rubocop',
+  command: ['rubocop', '--autocorrect', '$FILE'],
+  extensions: ['.rb', '.rake', '.gemspec', '.ru'],
   async enabled() {
-    return Bun.which("rubocop") !== null
+    return Bun.which('rubocop') !== null;
   },
-}
+};
 
 export const standardrb: Info = {
-  name: "standardrb",
-  command: ["standardrb", "--fix", "$FILE"],
-  extensions: [".rb", ".rake", ".gemspec", ".ru"],
+  name: 'standardrb',
+  command: ['standardrb', '--fix', '$FILE'],
+  extensions: ['.rb', '.rake', '.gemspec', '.ru'],
   async enabled() {
-    return Bun.which("standardrb") !== null
+    return Bun.which('standardrb') !== null;
   },
-}
+};
 
 export const htmlbeautifier: Info = {
-  name: "htmlbeautifier",
-  command: ["htmlbeautifier", "$FILE"],
-  extensions: [".erb", ".html.erb"],
+  name: 'htmlbeautifier',
+  command: ['htmlbeautifier', '$FILE'],
+  extensions: ['.erb', '.html.erb'],
   async enabled() {
-    return Bun.which("htmlbeautifier") !== null
+    return Bun.which('htmlbeautifier') !== null;
   },
-}
+};

package/src/format/index.ts

@@ -1,16 +1,16 @@
-import { Bus } from "../bus"
-import { File } from "../file"
-import { Log } from "../util/log"
-import path from "path"
-import z from "zod"
+import { Bus } from '../bus';
+import { File } from '../file';
+import { Log } from '../util/log';
+import path from 'path';
+import z from 'zod';
 
-import * as Formatter from "./formatter"
-import { Config } from "../config/config"
-import { mergeDeep } from "remeda"
-import { Instance } from "../project/instance"
+import * as Formatter from './formatter';
+import { Config } from '../config/config';
+import { mergeDeep } from 'remeda';
+import { Instance } from '../project/instance';
 
 export namespace Format {
-  const log = Log.create({ service: "format" })
+  const log = Log.create({ service: 'format' });
 
   export const Status = z
     .object({
@@ -19,119 +19,119 @@ export namespace Format {
       enabled: z.boolean(),
     })
     .meta({
-      ref: "FormatterStatus",
-    })
-  export type Status = z.infer<typeof Status>
+      ref: 'FormatterStatus',
+    });
+  export type Status = z.infer<typeof Status>;
 
   const state = Instance.state(async () => {
-    const enabled: Record<string, boolean> = {}
-    const cfg = await Config.get()
+    const enabled: Record<string, boolean> = {};
+    const cfg = await Config.get();
 
-    const formatters: Record<string, Formatter.Info> = {}
+    const formatters: Record<string, Formatter.Info> = {};
     if (cfg.formatter === false) {
-      log.info("all formatters are disabled")
+      log.info('all formatters are disabled');
       return {
         enabled,
         formatters,
-      }
+      };
     }
 
     for (const item of Object.values(Formatter)) {
-      formatters[item.name] = item
+      formatters[item.name] = item;
     }
     for (const [name, item] of Object.entries(cfg.formatter ?? {})) {
       if (item.disabled) {
-        delete formatters[name]
-        continue
+        delete formatters[name];
+        continue;
       }
       const result: Formatter.Info = mergeDeep(formatters[name] ?? {}, {
         command: [],
         extensions: [],
         ...item,
-      })
+      });
 
-      if (result.command.length === 0) continue
+      if (result.command.length === 0) continue;
 
-      result.enabled = async () => true
-      result.name = name
-      formatters[name] = result
+      result.enabled = async () => true;
+      result.name = name;
+      formatters[name] = result;
     }
 
     return {
       enabled,
       formatters,
-    }
-  })
+    };
+  });
 
   async function isEnabled(item: Formatter.Info) {
-    const s = await state()
-    let status = s.enabled[item.name]
+    const s = await state();
+    let status = s.enabled[item.name];
     if (status === undefined) {
-      status = await item.enabled()
-      s.enabled[item.name] = status
+      status = await item.enabled();
+      s.enabled[item.name] = status;
     }
-    return status
+    return status;
   }
 
   async function getFormatter(ext: string) {
-    const formatters = await state().then((x) => x.formatters)
-    const result = []
+    const formatters = await state().then((x) => x.formatters);
+    const result = [];
     for (const item of Object.values(formatters)) {
-      log.info("checking", { name: item.name, ext })
-      if (!item.extensions.includes(ext)) continue
-      if (!(await isEnabled(item))) continue
-      log.info("enabled", { name: item.name, ext })
-      result.push(item)
+      log.info('checking', { name: item.name, ext });
+      if (!item.extensions.includes(ext)) continue;
+      if (!(await isEnabled(item))) continue;
+      log.info('enabled', { name: item.name, ext });
+      result.push(item);
     }
-    return result
+    return result;
   }
 
   export async function status() {
-    const s = await state()
-    const result: Status[] = []
+    const s = await state();
+    const result: Status[] = [];
     for (const formatter of Object.values(s.formatters)) {
-      const enabled = await isEnabled(formatter)
+      const enabled = await isEnabled(formatter);
       result.push({
         name: formatter.name,
         extensions: formatter.extensions,
         enabled,
-      })
+      });
     }
-    return result
+    return result;
   }
 
   export function init() {
-    log.info("init")
+    log.info('init');
     Bus.subscribe(File.Event.Edited, async (payload) => {
-      const file = payload.properties.file
-      log.info("formatting", { file })
-      const ext = path.extname(file)
+      const file = payload.properties.file;
+      log.info('formatting', { file });
+      const ext = path.extname(file);
 
       for (const item of await getFormatter(ext)) {
-        log.info("running", { command: item.command })
+        log.info('running', { command: item.command });
         try {
           const proc = Bun.spawn({
-            cmd: item.command.map((x) => x.replace("$FILE", file)),
+            cmd: item.command.map((x) => x.replace('$FILE', file)),
             cwd: Instance.directory,
             env: { ...process.env, ...item.environment },
-            stdout: "ignore",
-            stderr: "ignore",
-          })
-          const exit = await proc.exited
+            stdout: 'ignore',
+            stderr: 'ignore',
+          });
+          const exit = await proc.exited;
           if (exit !== 0)
-            log.error("failed", {
+            log.error('failed', {
               command: item.command,
               ...item.environment,
-            })
+            });
         } catch (error) {
-          log.error("failed to format file", {
+          log.error('failed to format file', {
             error,
             command: item.command,
             ...item.environment,
             file,
-          })
+          });
         }
       }
-    })
+    });
   }
 }