opencode-teammate 0.1.0

package/src/utils/frontmatter.ts

@@ -0,0 +1,317 @@
+import { isString, isObject, isArray, isNullish } from "radashi";
+
+export type Metadata = Record<string, unknown>;
+
+export interface Options {
+  /** @default '---' */
+  delimiter?: string;
+}
+
+/**
+ * Parses frontmatter from a content string and returns the data object.
+ *
+ * Extracts YAML-formatted frontmatter from the beginning of a string, parsing it
+ * into a JavaScript object. The frontmatter must be enclosed by delimiter lines
+ * (default: `---`).
+ *
+ * @param content - The string containing frontmatter and optional content
+ * @param options - Configuration options
+ * @param options.delimiter - The delimiter string to use (default: '---')
+ *
+ * @returns Parsed frontmatter as a data object
+ *
+ * @example
+ * ```ts
+ * const content = `---
+ * title: My Title
+ * description: My Description
+ * nested:
+ *   key: value
+ * ---
+ *
+ * any other content`;
+ *
+ * const metadata = parse(content);
+ * // { title: "My Title", description: "My Description", nested: { key: "value" } }
+ * ```
+ */
+export function parse(content: string, options?: Options): Metadata {
+  const { metadata } = extract(content, options);
+  return metadata;
+}
+
+/**
+ * Extracts both frontmatter data and remaining content from a string.
+ *
+ * Similar to `parse()`, but also returns the content that appears after the
+ * closing frontmatter delimiter. Useful when you need to process both metadata
+ * and document body.
+ *
+ * @param content - The string containing frontmatter and content
+ * @param options - Configuration options
+ * @param options.delimiter - The delimiter string to use (default: '---')
+ *
+ * @returns An object containing both `metadata` (parsed frontmatter) and `content` (remaining text)
+ *
+ * @example
+ * ```ts
+ * const content = `---
+ * title: My Title
+ * ---
+ *
+ * # Main Content
+ * This is the body.`;
+ *
+ * const result = extract(content);
+ * // {
+ * //   metadata: { title: "My Title" },
+ * //   content: "\n# Main Content\nThis is the body."
+ * // }
+ * ```
+ */
+export function extract(
+  content: string,
+  options?: Options,
+): { metadata: Metadata; content: string } {
+  const delimiter = options?.delimiter ?? "---";
+
+  // Check if content starts with delimiter (allowing leading whitespace)
+  if (!content.trimStart().startsWith(delimiter)) {
+    return { metadata: {}, content };
+  }
+
+  const lines = content.split("\n");
+  let startIndex = -1;
+  let endIndex = -1;
+
+  // Find the opening delimiter
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i]?.trim() === delimiter) {
+      startIndex = i;
+      break;
+    }
+  }
+
+  // No valid opening delimiter found
+  if (startIndex === -1) {
+    return { metadata: {}, content };
+  }
+
+  // Find the closing delimiter
+  for (let i = startIndex + 1; i < lines.length; i++) {
+    if (lines[i]?.trim() === delimiter) {
+      endIndex = i;
+      break;
+    }
+  }
+
+  // No valid closing delimiter found
+  if (endIndex === -1) {
+    return { metadata: {}, content };
+  }
+
+  // Extract and parse the frontmatter content
+  const frontmatterLines = lines.slice(startIndex + 1, endIndex);
+  const yamlContent = frontmatterLines.join("\n");
+  const metadata = parseYAML(yamlContent);
+
+  // Extract remaining content after frontmatter
+  const remainingContent = lines
+    .slice(endIndex + 1)
+    .join("\n")
+    .replace(/^\n+/, "");
+
+  return { metadata, content: remainingContent };
+}
+
+/**
+ * Converts a data object into YAML-formatted frontmatter string.
+ *
+ * Serializes a JavaScript object into YAML format and wraps it with delimiter
+ * lines. The output can be prepended to content to create a complete document
+ * with frontmatter.
+ *
+ * @param data - The data object to convert to frontmatter
+ * @param options - Configuration options
+ * @param options.delimiter - The delimiter string to use (default: '---')
+ *
+ * @returns YAML frontmatter string with delimiters
+ *
+ * @example
+ * ```ts
+ * const data = {
+ *   title: "My Title",
+ *   nested: { key: "value" }
+ * };
+ *
+ * const frontmatter = stringify(data);
+ * // ---
+ * // title: My Title
+ * // nested:
+ * //   key: value
+ * // ---
+ * ```
+ */
+export function stringify(data: Metadata, options?: Options): string {
+  const delimiter = options?.delimiter ?? "---";
+  const yamlContent = stringifyYAML(data);
+  return `${delimiter}\n${yamlContent}${delimiter}\n`;
+}
+
+export function apply(content: string, data: Metadata, options?: Options): string {
+  const frontmatter = stringify(data, options);
+  return `${frontmatter}\n${content}`;
+}
+
+/**
+ * Parses a YAML string into a JavaScript object.
+ *
+ * This is a lightweight YAML parser that supports basic key-value pairs,
+ * nested objects, and common data types. It's designed specifically for
+ * frontmatter use cases.
+ *
+ * Supported features:
+ * - String, number, boolean, and null values
+ * - Nested objects (via indentation)
+ * - Single and double quoted strings
+ * - Comments (lines starting with #)
+ *
+ * @param yaml - The YAML string to parse
+ * @returns Parsed data object
+ */
+function parseYAML(yaml: string): Metadata {
+  const result: Metadata = {};
+  const lines = yaml.split("\n");
+  const stack: Array<{ obj: Metadata; indent: number }> = [{ obj: result, indent: -1 }];
+
+  for (const line of lines) {
+    // Skip empty lines and comments
+    if (!line.trim() || line.trim().startsWith("#")) {
+      continue;
+    }
+
+    const indent = line.length - (line.trimStart()?.length ?? 0);
+    const trimmed = line.trim();
+
+    // Pop stack to find the correct parent based on indentation
+    while (stack.length > 1) {
+      const top = stack[stack.length - 1];
+      if (!top || indent > top.indent) {
+        break;
+      }
+      stack.pop();
+    }
+
+    // Parse key-value pair
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
+    }
+
+    const key = trimmed.substring(0, colonIndex).trim();
+    const valueStr = trimmed.substring(colonIndex + 1).trim();
+
+    const currentObj = stack[stack.length - 1]?.obj;
+    if (!currentObj) continue;
+
+    if (valueStr === "") {
+      // Empty value indicates a nested object
+      const nestedObj: Metadata = {};
+      currentObj[key] = nestedObj;
+      stack.push({ obj: nestedObj, indent });
+    } else {
+      // Parse the value and assign it
+      if (currentObj) {
+        currentObj[key] = parseYAMLValue(valueStr);
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Parses a YAML value string into its JavaScript type.
+ *
+ * Handles type coercion for strings, numbers, booleans, and null values.
+ * Quoted strings are unquoted, and special YAML values are converted.
+ *
+ * @param value - The YAML value string to parse
+ * @returns The parsed value with appropriate type
+ */
+function parseYAMLValue(value: string): unknown {
+  // Remove quotes from quoted strings
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1);
+  }
+
+  // Parse boolean values
+  if (value === "true") return true;
+  if (value === "false") return false;
+
+  // Parse null/undefined
+  if (value === "null" || value === "~") return null;
+
+  // Try to parse as number
+  const num = Number(value);
+  if (!Number.isNaN(num) && value !== "") {
+    return num;
+  }
+
+  // Return as string by default
+  return value;
+}
+
+/**
+ * Converts a JavaScript object to YAML format.
+ *
+ * Recursively serializes an object into YAML syntax with proper indentation.
+ * Handles nested objects, arrays, and various data types. Strings with special
+ * characters are automatically quoted.
+ *
+ * @param data - The data object to stringify
+ * @param indent - Current indentation level (internal use)
+ * @returns YAML formatted string
+ */
+function stringifyYAML(data: Metadata, indent = 0): string {
+  const indentStr = "  ".repeat(indent);
+  let result = "";
+
+  for (const [key, value] of Object.entries(data)) {
+    // Handle null and undefined
+    if (isNullish(value)) {
+      result += `${indentStr}${key}: null\n`;
+    }
+    // Handle nested objects (but not arrays)
+    else if (isObject(value) && !isArray(value)) {
+      result += `${indentStr}${key}:\n`;
+      result += stringifyYAML(value as Metadata, indent + 1);
+    }
+    // Handle strings
+    else if (isString(value)) {
+      // Quote strings that contain special YAML characters
+      const needsQuotes = value.includes(":") || value.includes("#") || value.includes("\n");
+      result += `${indentStr}${key}: ${needsQuotes ? `"${value}"` : value}\n`;
+    }
+    // Handle arrays
+    else if (isArray(value)) {
+      result += `${indentStr}${key}:\n`;
+      for (const item of value) {
+        if (isObject(item) && !isArray(item)) {
+          result += `${indentStr}- \n${stringifyYAML(item as Metadata, indent + 2)}`;
+        } else {
+          result += `${indentStr}  - ${item}\n`;
+        }
+      }
+    }
+    // Handle primitives (numbers, booleans, etc.)
+    else {
+      result += `${indentStr}${key}: ${value}\n`;
+    }
+  }
+
+  return result;
+}

package/src/utils/opencode.ts

@@ -0,0 +1,102 @@
+import { createOpencodeClient, type OpencodeClientConfig } from "@opencode-ai/sdk/v2/client";
+import { assign } from "radashi";
+
+const STORE = Bun.file(
+  `${Bun.env.HOME}/Library/Application Support/ai.opencode.desktop/store.json`,
+);
+
+interface ServerConfig {
+  username?: string;
+  password?: string;
+  hostname?: string;
+  port?: number;
+}
+
+const context = {
+  client: Bun.env.OPENCODE_CLIENT ?? "unknown",
+  password: Bun.env.OPENCODE_SERVER_PASSWORD,
+  username: Bun.env.OPENCODE_SERVER_USERNAME,
+};
+
+export async function register(options: {
+  project?: { id?: string; worktree?: string };
+  directory?: string;
+}) {
+  if (context.client === "desktop") {
+    const server = await getServer();
+    const config = {
+      username: context.username,
+      password: context.password,
+      seenAt: new Date(),
+      directory: options.directory,
+      project: options.project,
+      ...server,
+    };
+
+    await Bun.write(STORE, JSON.stringify(config));
+
+    return createOpencodeClient(createOpencodeClientConfigFromServerConfig(config));
+  }
+
+  return createOpencodeClient({
+    directory: options.directory,
+  });
+}
+
+export interface ClientClientOptions extends OpencodeClientConfig {
+  directory?: string;
+  loopUpForDesktopServer?: boolean;
+}
+
+export async function createClient(options: ClientClientOptions) {
+  if (options.loopUpForDesktopServer) {
+    const registered = await createRegisteredServerConfig();
+
+    if (registered) {
+      const client = createOpencodeClient(assign(options, registered ?? {}));
+
+      const health = await client.global.health();
+      if (health.data?.healthy) return client;
+      else console.warn("Desktop server is not healthy, re-launch Opencode app");
+    } else console.warn("Desktop server is not registered, launch Opencode app");
+  }
+
+  return createOpencodeClient(options);
+}
+
+async function createRegisteredServerConfig() {
+  const exists = await STORE.exists();
+  if (!exists) return undefined;
+
+  const config: ServerConfig = await STORE.json();
+
+  return createOpencodeClientConfigFromServerConfig(config);
+}
+
+function createOpencodeClientConfigFromServerConfig(
+  server: ServerConfig,
+): OpencodeClientConfig | undefined {
+  return {
+    baseUrl: `http://${server.hostname}:${server.port}`,
+    headers: {
+      Authorization: `Basic ${btoa(`${server.username}:${server.password}`)}`,
+    },
+  } satisfies OpencodeClientConfig;
+}
+
+async function getServer() {
+  const process =
+    await Bun.$`ps ax -o pid=,command= | grep "opencode-cli " | grep "serve" | grep -v grep`
+      .nothrow()
+      .text();
+
+  const pid = process.match(/^(\d+)\s+/)?.[1];
+  const hostname = process.match(/--hostname\s+([\S]+)/)?.[1];
+  const port = process.match(/--port\s+(\d+)/)?.[1];
+
+  return {
+    pid: pid ? parseInt(pid, 10) : undefined,
+    hostname,
+    port: port ? parseInt(port, 10) : undefined,
+  };
+}

package/src/utils/polling.ts

@@ -0,0 +1,41 @@
+import { type DurationString, isEmpty, parseDuration, sleep } from "radashi";
+
+export interface PollOptions {
+  interval?: DurationString;
+  /** Stop polling when the result is empty or undefined */
+  exitOnEmpty?: boolean;
+}
+
+export function poll<T extends Array<unknown>>(
+  fn: () => Promise<T | undefined>,
+  options?: PollOptions,
+): AsyncGenerator<T[number]>;
+
+export function poll<T>(fn: () => Promise<T | undefined>, options?: PollOptions): AsyncGenerator<T>;
+
+export async function* poll(fn: () => Promise<unknown>, options?: PollOptions) {
+  const interval = parseDuration(options?.interval ?? "1s");
+
+  while (true) {
+    const result = await fn();
+
+    if (Array.isArray(result)) {
+      if (isEmpty(result) && options?.exitOnEmpty) break;
+      yield* result;
+    } else if (result === undefined && options?.exitOnEmpty) {
+      break;
+    } else yield result;
+
+    await sleep(interval);
+  }
+}
+
+export type WaitForOptions = Omit<PollOptions, "exitOnEmpty">;
+
+export async function waitFor<T>(fn: () => Promise<T | undefined>, options?: WaitForOptions) {
+  for await (const result of poll(fn, options)) {
+    if (result) return result;
+  }
+
+  throw Error("Timeout: waiting for condition");
+}

package/src/utils/projects.ts

@@ -0,0 +1,35 @@
+import type { OpencodeClient, Project } from "@opencode-ai/sdk/v2/client";
+import { prompt } from "@bunli/utils";
+import { assert } from "radashi";
+
+export async function use(client: OpencodeClient, directory?: string) {
+  const { data: project } = await client.project.current({
+    directory: directory ?? process.cwd(),
+  });
+
+  if (project && project.id !== "global") return project.worktree;
+
+  const { data: projects, error } = await client.project.list();
+  assert(error === undefined, `Failed to list projects: ${error}`);
+  assert(projects, `No projects found`);
+  assert(projects.length > 0, `No projects found: ${projects.length}`);
+
+  return prompt.select("Select a project", {
+    options: projects.map((project) => ({
+      label: project.name ?? project.worktree,
+      value: project.worktree,
+      hint: project.name
+        ? `${project.worktree} - ${project.id.slice(0, 5)}`
+        : project.id.slice(0, 5),
+    })),
+  });
+}
+
+export function getProjectLabel(project: Project) {
+  return project.name ?? project.worktree;
+}
+
+export function getProjectHint(project: Project) {
+  const shortId = project.id.slice(0, 5);
+  return project.name ? `${project.worktree} - ${shortId}` : shortId;
+}

package/src/utils/shell/client.spec.ts

@@ -0,0 +1,106 @@
+import { describe, expect, expectTypeOf, it } from "bun:test";
+import { $ } from "bun";
+import { toResult } from "radashi";
+
+import * as client from "./client";
+import { InvalidExitCodeError, ShellError } from "./error";
+
+const PRINT_FLAGS_SH = `
+  printf "%d:" "$#"
+  for arg in "$@"; do
+    printf " <%s>" "$arg"
+  done
+  echo ""
+`;
+
+describe("shell client wrapper", () => {
+  it("returns the same client when already a client", () => {
+    const shell = client.create($);
+    expect(client.use(shell)).toBe(shell);
+  });
+
+  it("formats CLI options and positional arguments", async () => {
+    const shell = client.create($);
+
+    const [, output] = await shell`bash -c ${PRINT_FLAGS_SH} -- ${"pos"} ${{
+      flag: true,
+      count: 3,
+      list: ["a", "b"],
+      name: "hello world",
+      skip: undefined,
+    }}`.text();
+
+    expect(output).toBe("5: <pos> <--flag> <--count='3'> <--list=a,b> <--name='hello world'>");
+  });
+
+  it("ignores empty options objects", async () => {
+    const shell = client.create($);
+    const [, output] = await shell`bash -c ${PRINT_FLAGS_SH} -- pos ${{}}`.text();
+
+    expect(output).toBe("1: <pos>");
+  });
+
+  it("parses JSON output", async () => {
+    const shell = client.create($);
+    type Output = { ok: true };
+
+    const output = await shell`echo '{\"ok\":true}'`.json<Output>();
+    expect(output).toEqual({ ok: true });
+    expectTypeOf(output).toEqualTypeOf<Output>();
+
+    const second = await shell<Output>`echo '{\"ok\":true}'`.json();
+    expectTypeOf(second).toEqualTypeOf(output);
+  });
+
+  it("returns an error when stdout JSON parsing fails", async () => {
+    const shell = client.create($);
+
+    const [error] = await toResult(shell`echo 'not json'`.json());
+
+    expect(error).toBeInstanceOf(ShellError);
+    expect(error?.message).toBe("not json");
+    expect(error?.cause).toBeInstanceOf(SyntaxError);
+  });
+
+  it("falls back to raw stderr when JSON parsing is failing", async () => {
+    const shell = client.create($);
+
+    const [error] = await toResult(shell`echo "This is an error message" 2> /dev/stderr`.json());
+
+    expect(error).toBeInstanceOf(ShellError);
+    expect(error?.message).toBe("This is an error message");
+    expect(error?.cause).toBeInstanceOf(SyntaxError);
+  });
+
+  it("uses chained configuration methods with real commands", async () => {
+    const shell = client.create($);
+
+    const [, pwd] = await shell.cwd(import.meta.dir)`pwd`.text();
+    expect(pwd).toBe(import.meta.dir);
+
+    const [, value] = await shell.env({
+      TEST_ENV: "works",
+    })`printenv TEST_ENV`.text();
+    expect(value).toBe("works");
+  });
+
+  it("keeps the bun shell context", async () => {
+    const shell = client.create($.cwd(import.meta.dir).env({ TEST_ENV: "works" }));
+
+    const [, pwd] = await shell`pwd`.text();
+    expect(pwd).toBe(import.meta.dir);
+
+    const [, value] = await shell`printenv TEST_ENV`.text();
+    expect(value).toBe("works");
+  });
+
+  it("text() output returns error on exit 1", async () => {
+    const shell = client.create($);
+
+    const [error, output] = await shell`exit 1`.text();
+    expect(output).toBeUndefined();
+    expect(error).toBeInstanceOf(ShellError);
+    expect(error?.message).toBe("Unknown shell error");
+    expect(error?.cause).toBeInstanceOf(InvalidExitCodeError);
+  });
+});