saeeol 1.2.5 → 1.2.7

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

@@ -1,161 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,224 +0,0 @@
-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 },
-)