saeeol 1.3.0 → 1.4.0

package/test/cli/tui/markdown.test.ts

@@ -0,0 +1,161 @@
+import { describe, expect, it } from "bun:test"
+import { formatMarkdownTables } from "../../../src/cli/cmd/tui/util/markdown"
+
+describe("formatMarkdownTables", () => {
+  it("formats a simple table with fixed-width columns", () => {
+    const input = `| Name | Age |
+| --- | --- |
+| Alice | 30 |
+| Bob | 25 |`
+
+    const result = formatMarkdownTables(input)
+
+    // Each column should be padded to consistent width
+    const lines = result.split("\n")
+    expect(lines).toHaveLength(4)
+
+    // Check that all pipes are aligned
+    const pipePositions = lines.map((line) => {
+      const positions: number[] = []
+      for (let i = 0; i < line.length; i++) {
+        if (line[i] === "|") positions.push(i)
+      }
+      return positions
+    })
+
+    // All rows should have same pipe positions
+    for (let i = 1; i < pipePositions.length; i++) {
+      expect(pipePositions[i]).toEqual(pipePositions[0])
+    }
+  })
+
+  it("handles tables with varying cell widths", () => {
+    const input = `| Short | Very Long Header |
+| --- | --- |
+| A | B |
+| Much Longer Cell | X |`
+
+    const result = formatMarkdownTables(input)
+    const lines = result.split("\n")
+
+    // Column widths should be normalized
+    expect(lines[0]).toContain("Short")
+    expect(lines[0]).toContain("Very Long Header")
+    expect(lines[3]).toContain("Much Longer Cell")
+  })
+
+  it("preserves column alignment", () => {
+    const input = `| Left | Center | Right |
+| :--- | :---: | ---: |
+| 1 | 2 | 3 |`
+
+    const result = formatMarkdownTables(input)
+    const lines = result.split("\n")
+
+    // Check that alignment markers are preserved
+    expect(lines[1]).toContain(":--")
+    expect(lines[1]).toMatch(/:.*:/) // center has colons on both sides
+    expect(lines[1]).toMatch(/-+:/) // right-aligned ends with colon
+  })
+
+  it("handles content without tables unchanged", () => {
+    const input = `# Hello World
+
+This is a paragraph.
+
+- List item 1
+- List item 2`
+
+    const result = formatMarkdownTables(input)
+    expect(result).toBe(input)
+  })
+
+  it("handles multiple tables in content", () => {
+    const input = `# First Table
+
+| A | B |
+| --- | --- |
+| 1 | 2 |
+
+Some text between tables.
+
+| Column One | Column Two |
+| --- | --- |
+| Value | Another Value |`
+
+    const result = formatMarkdownTables(input)
+
+    // Both tables should be formatted
+    expect(result).toContain("| A ")
+    expect(result).toContain("| Column One ")
+  })
+
+  it("handles tables with empty cells", () => {
+    const input = `| Header 1 | Header 2 |
+| --- | --- |
+| Value |  |
+|  | Value |`
+
+    const result = formatMarkdownTables(input)
+    const lines = result.split("\n")
+
+    // Should still format correctly with empty cells
+    expect(lines).toHaveLength(4)
+    // Pipes should still be aligned
+    const firstPipe = lines[0].indexOf("|")
+    for (const line of lines) {
+      expect(line[firstPipe]).toBe("|")
+    }
+  })
+
+  it("handles tables with extra columns in some rows", () => {
+    const input = `| A | B |
+| --- | --- |
+| 1 | 2 | 3 |`
+
+    const result = formatMarkdownTables(input)
+    const lines = result.split("\n")
+
+    // Should handle the extra column
+    expect(lines[2]).toContain("3")
+  })
+
+  it("ignores malformed tables", () => {
+    const input = `| Not a table
+Just some text with pipes |`
+
+    const result = formatMarkdownTables(input)
+    expect(result).toBe(input)
+  })
+
+  it("handles tables without leading/trailing pipes", () => {
+    // Standard markdown tables require pipes
+    const input = `Name | Age
+--- | ---
+Alice | 30`
+
+    const result = formatMarkdownTables(input)
+    // Without proper pipe syntax, this shouldn't be formatted as a table
+    expect(result).toBe(input)
+  })
+
+  it("formats table embedded in markdown content", () => {
+    const input = `Here is some information:
+
+| Feature | Status |
+| --- | --- |
+| Tables | Supported |
+| Lists | Supported |
+
+And some more text after the table.`
+
+    const result = formatMarkdownTables(input)
+
+    // The table portion should be formatted
+    expect(result).toContain("| Feature")
+    expect(result).toContain("| Tables")
+    // Non-table content should be preserved
+    expect(result).toContain("Here is some information:")
+    expect(result).toContain("And some more text after the table.")
+  })
+})

package/test/cli/tui/plugin-add.test.ts

@@ -0,0 +1,111 @@
+import { expect, spyOn, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { pathToFileURL } from "url"
+import { tmpdir } from "../../fixture/fixture"
+import { createTuiPluginApi } from "../../fixture/tui-plugin"
+import { TuiConfig } from "../../../src/cli/cmd/tui/config/tui"
+
+const { TuiPluginRuntime } = await import("../../../src/cli/cmd/tui/plugin/runtime")
+
+test("adds tui plugin at runtime from spec", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const file = path.join(dir, "add-plugin.ts")
+      const spec = pathToFileURL(file).href
+      const marker = path.join(dir, "add.txt")
+
+      await Bun.write(
+        file,
+        `export default {
+  id: "demo.add",
+  tui: async () => {
+    await Bun.write(${JSON.stringify(marker)}, "called")
+  },
+}
+`,
+      )
+
+      return { spec, marker }
+    },
+  })
+
+  process.env.SAEEOL_PLUGIN_META_FILE = path.join(tmp.path, "plugin-meta.json")
+  const config: TuiConfig.Info = {
+    plugin: [],
+    plugin_origins: undefined,
+  }
+  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
+
+  try {
+    await TuiPluginRuntime.init({
+      api: createTuiPluginApi(),
+      config,
+    })
+
+    await expect(TuiPluginRuntime.addPlugin(tmp.extra.spec)).resolves.toBe(true)
+    await expect(fs.readFile(tmp.extra.marker, "utf8")).resolves.toBe("called")
+    expect(TuiPluginRuntime.list().find((item) => item.id === "demo.add")).toEqual({
+      id: "demo.add",
+      source: "file",
+      spec: tmp.extra.spec,
+      target: tmp.extra.spec,
+      enabled: true,
+      active: true,
+    })
+  } finally {
+    await TuiPluginRuntime.dispose()
+    cwd.mockRestore()
+    wait.mockRestore()
+    delete process.env.SAEEOL_PLUGIN_META_FILE
+  }
+})
+
+test("retries runtime add for file plugins after dependency wait", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const mod = path.join(dir, "retry-plugin")
+      const spec = pathToFileURL(mod).href
+      const marker = path.join(dir, "retry-add.txt")
+      await fs.mkdir(mod, { recursive: true })
+      return { mod, spec, marker }
+    },
+  })
+
+  process.env.SAEEOL_PLUGIN_META_FILE = path.join(tmp.path, "plugin-meta.json")
+  const config: TuiConfig.Info = {
+    plugin: [],
+    plugin_origins: undefined,
+  }
+  const wait = spyOn(TuiConfig, "waitForDependencies").mockImplementation(async () => {
+    await Bun.write(
+      path.join(tmp.extra.mod, "index.ts"),
+      `export default {
+  id: "demo.add.retry",
+  tui: async () => {
+    await Bun.write(${JSON.stringify(tmp.extra.marker)}, "called")
+  },
+}
+`,
+    )
+  })
+  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
+
+  try {
+    await TuiPluginRuntime.init({
+      api: createTuiPluginApi(),
+      config,
+    })
+
+    await expect(TuiPluginRuntime.addPlugin(tmp.extra.spec)).resolves.toBe(true)
+    await expect(fs.readFile(tmp.extra.marker, "utf8")).resolves.toBe("called")
+    expect(wait).toHaveBeenCalledTimes(1)
+    expect(TuiPluginRuntime.list().find((item) => item.id === "demo.add.retry")?.active).toBe(true)
+  } finally {
+    await TuiPluginRuntime.dispose()
+    cwd.mockRestore()
+    wait.mockRestore()
+    delete process.env.SAEEOL_PLUGIN_META_FILE
+  }
+})

package/test/cli/tui/plugin-install.test.ts

@@ -0,0 +1,87 @@
+import { expect, spyOn, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { pathToFileURL } from "url"
+import { tmpdir } from "../../fixture/fixture"
+import { createTuiPluginApi } from "../../fixture/tui-plugin"
+import { TuiConfig } from "../../../src/cli/cmd/tui/config/tui"
+
+const { TuiPluginRuntime } = await import("../../../src/cli/cmd/tui/plugin/runtime")
+
+test("installs plugin without loading it", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const file = path.join(dir, "install-plugin.ts")
+      const spec = pathToFileURL(file).href
+      const marker = path.join(dir, "install.txt")
+
+      await Bun.write(
+        path.join(dir, "package.json"),
+        JSON.stringify(
+          {
+            name: "demo-install-plugin",
+            type: "module",
+            exports: {
+              "./tui": {
+                import: "./install-plugin.ts",
+                config: { marker },
+              },
+            },
+          },
+          null,
+          2,
+        ),
+      )
+
+      await Bun.write(
+        file,
+        `export default {
+  id: "demo.install",
+  tui: async (_api, options) => {
+    if (!options?.marker) return
+    await Bun.write(options.marker, "loaded")
+  },
+}
+`,
+      )
+
+      return { spec, marker }
+    },
+  })
+
+  process.env.SAEEOL_PLUGIN_META_FILE = path.join(tmp.path, "plugin-meta.json")
+  const config: TuiConfig.Info = {
+    plugin: [],
+    plugin_origins: undefined,
+  }
+  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
+  const api = createTuiPluginApi({
+    state: {
+      path: {
+        state: path.join(tmp.path, "state.json"),
+        config: path.join(tmp.path, "tui.json"),
+        worktree: tmp.path,
+        directory: tmp.path,
+      },
+    },
+  })
+
+  try {
+    await TuiPluginRuntime.init({ api, config })
+    const out = await TuiPluginRuntime.installPlugin(tmp.extra.spec)
+    expect(out).toMatchObject({
+      ok: true,
+      tui: true,
+    })
+
+    await expect(fs.readFile(tmp.extra.marker, "utf8")).rejects.toThrow()
+    await expect(TuiPluginRuntime.addPlugin(tmp.extra.spec)).resolves.toBe(true)
+    await expect(fs.readFile(tmp.extra.marker, "utf8")).resolves.toBe("loaded")
+  } finally {
+    await TuiPluginRuntime.dispose()
+    cwd.mockRestore()
+    wait.mockRestore()
+    delete process.env.SAEEOL_PLUGIN_META_FILE
+  }
+})

package/test/cli/tui/plugin-lifecycle.test.ts

@@ -0,0 +1,224 @@
+import { expect, spyOn, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { pathToFileURL } from "url"
+import { tmpdir } from "../../fixture/fixture"
+import { createTuiPluginApi } from "../../fixture/tui-plugin"
+import { mockTuiRuntime } from "../../fixture/tui-runtime"
+
+const { TuiPluginRuntime } = await import("../../../src/cli/cmd/tui/plugin/runtime")
+
+test("runs onDispose callbacks with aborted signal and is idempotent", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const file = path.join(dir, "plugin.ts")
+      const spec = pathToFileURL(file).href
+      const marker = path.join(dir, "marker.txt")
+
+      await Bun.write(
+        file,
+        `export default {
+  id: "demo.lifecycle",
+  tui: async (api, options) => {
+    api.event.on("event.test", () => {})
+    api.route.register([{ name: "lifecycle.route", render: () => null }])
+    api.lifecycle.onDispose(async () => {
+      const prev = await Bun.file(options.marker).text().catch(() => "")
+      await Bun.write(options.marker, prev + "custom\\n")
+    })
+    api.lifecycle.onDispose(async () => {
+      const prev = await Bun.file(options.marker).text().catch(() => "")
+      await Bun.write(options.marker, prev + "aborted:" + String(api.lifecycle.signal.aborted) + "\\n")
+    })
+  },
+}
+`,
+      )
+
+      return { spec, marker }
+    },
+  })
+
+  const { config, restore } = mockTuiRuntime(tmp.path, [[tmp.extra.spec, { marker: tmp.extra.marker }]])
+
+  try {
+    await TuiPluginRuntime.init({ api: createTuiPluginApi(), config })
+    await TuiPluginRuntime.dispose()
+
+    const marker = await fs.readFile(tmp.extra.marker, "utf8")
+    expect(marker).toContain("custom")
+    expect(marker).toContain("aborted:true")
+
+    // second dispose is a no-op
+    await TuiPluginRuntime.dispose()
+    const after = await fs.readFile(tmp.extra.marker, "utf8")
+    expect(after).toBe(marker)
+  } finally {
+    await TuiPluginRuntime.dispose()
+    restore()
+  }
+})
+
+test("rolls back failed plugin and continues loading next", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const bad = path.join(dir, "bad-plugin.ts")
+      const good = path.join(dir, "good-plugin.ts")
+      const badSpec = pathToFileURL(bad).href
+      const goodSpec = pathToFileURL(good).href
+      const badMarker = path.join(dir, "bad-cleanup.txt")
+      const goodMarker = path.join(dir, "good-called.txt")
+
+      await Bun.write(
+        bad,
+        `export default {
+  id: "demo.bad",
+  tui: async (api, options) => {
+    api.route.register([{ name: "bad.route", render: () => null }])
+    api.lifecycle.onDispose(async () => {
+      await Bun.write(options.bad_marker, "cleaned")
+    })
+    throw new Error("bad plugin")
+  },
+}
+`,
+      )
+
+      await Bun.write(
+        good,
+        `export default {
+  id: "demo.good",
+  tui: async (_api, options) => {
+    await Bun.write(options.good_marker, "called")
+  },
+}
+`,
+      )
+
+      return { badSpec, goodSpec, badMarker, goodMarker }
+    },
+  })
+
+  const { config, restore } = mockTuiRuntime(tmp.path, [
+    [tmp.extra.badSpec, { bad_marker: tmp.extra.badMarker }],
+    [tmp.extra.goodSpec, { good_marker: tmp.extra.goodMarker }],
+  ])
+
+  try {
+    await TuiPluginRuntime.init({ api: createTuiPluginApi(), config })
+    // bad plugin's onDispose ran during rollback
+    await expect(fs.readFile(tmp.extra.badMarker, "utf8")).resolves.toBe("cleaned")
+    // good plugin still loaded
+    await expect(fs.readFile(tmp.extra.goodMarker, "utf8")).resolves.toBe("called")
+  } finally {
+    await TuiPluginRuntime.dispose()
+    restore()
+  }
+})
+
+test("assigns sequential slot ids scoped to plugin", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const file = path.join(dir, "slot-plugin.ts")
+      const spec = pathToFileURL(file).href
+      const marker = path.join(dir, "slot-setup.txt")
+
+      await Bun.write(
+        file,
+        `import fs from "fs"
+
+const mark = (label) => {
+  fs.appendFileSync(${JSON.stringify(marker)}, label + "\\n")
+}
+
+export default {
+  id: "demo.slot",
+  tui: async (api) => {
+    const one = api.slots.register({
+      id: 1,
+      setup: () => { mark("one") },
+      slots: { home_logo() { return null } },
+    })
+    const two = api.slots.register({
+      id: 2,
+      setup: () => { mark("two") },
+      slots: { home_bottom() { return null } },
+    })
+    mark("id:" + one)
+    mark("id:" + two)
+  },
+}
+`,
+      )
+
+      return { spec, marker }
+    },
+  })
+
+  const { config, restore } = mockTuiRuntime(tmp.path, [tmp.extra.spec])
+  const err = spyOn(console, "error").mockImplementation(() => {})
+
+  try {
+    await TuiPluginRuntime.init({ api: createTuiPluginApi(), config })
+
+    const marker = await fs.readFile(tmp.extra.marker, "utf8")
+    expect(marker).toContain("one")
+    expect(marker).toContain("two")
+    expect(marker).toContain("id:demo.slot")
+    expect(marker).toContain("id:demo.slot:1")
+
+    // no initialization failures
+    const hit = err.mock.calls.find(
+      (item) => typeof item[0] === "string" && item[0].includes("failed to initialize tui plugin"),
+    )
+    expect(hit).toBeUndefined()
+  } finally {
+    await TuiPluginRuntime.dispose()
+    err.mockRestore()
+    restore()
+  }
+})
+
+test(
+  "times out hanging plugin cleanup on dispose",
+  async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        const file = path.join(dir, "timeout-plugin.ts")
+        const spec = pathToFileURL(file).href
+
+        await Bun.write(
+          file,
+          `export default {
+  id: "demo.timeout",
+  tui: async (api) => {
+    api.lifecycle.onDispose(() => new Promise(() => {}))
+  },
+}
+`,
+        )
+
+        return { spec }
+      },
+    })
+
+    const { config, restore } = mockTuiRuntime(tmp.path, [tmp.extra.spec])
+
+    try {
+      await TuiPluginRuntime.init({ api: createTuiPluginApi(), config })
+
+      const done = await new Promise<string>((resolve) => {
+        const timer = setTimeout(() => resolve("timeout"), 7000)
+        void TuiPluginRuntime.dispose().then(() => {
+          clearTimeout(timer)
+          resolve("done")
+        })
+      })
+      expect(done).toBe("done")
+    } finally {
+      await TuiPluginRuntime.dispose()
+      restore()
+    }
+  },
+  { timeout: 15000 },
+)