rimuru-ai 1.19.0

package/src/cli/cmd/github.shared.ts

@@ -0,0 +1,30 @@
+import type { SessionV1 } from "@rimurucode-ai/core/v1/session"
+
+export { parseGitHubRemote } from "@/util/repository"
+
+/**
+ * Extracts displayable text from assistant response parts.
+ * Returns null for non-text responses (signals summary needed).
+ * Throws only for truly empty responses.
+ */
+export function extractResponseText(parts: SessionV1.Part[]): string | null {
+  const textPart = parts.findLast((p) => p.type === "text")
+  if (textPart) return textPart.text
+
+  // Non-text parts (tools, reasoning, step-start/step-finish, etc.) - signal summary needed
+  if (parts.length > 0) return null
+
+  throw new Error("Failed to parse response: no parts returned")
+}
+
+/**
+ * Formats a PROMPT_TOO_LARGE error message with details about files in the prompt.
+ * Content is base64 encoded, so we calculate original size by multiplying by 0.75.
+ */
+export function formatPromptTooLargeError(files: { filename: string; content: string }[]): string {
+  const fileDetails =
+    files.length > 0
+      ? `\n\nFiles in prompt:\n${files.map((f) => `  - ${f.filename} (${((f.content.length * 0.75) / 1024).toFixed(0)} KB)`).join("\n")}`
+      : ""
+  return `PROMPT_TOO_LARGE: The prompt exceeds the model's context limit.${fileDetails}`
+}

package/src/cli/cmd/github.ts

@@ -0,0 +1,42 @@
+import { Effect } from "effect"
+import { cmd } from "./cmd"
+import { effectCmd } from "../effect-cmd"
+
+export { extractResponseText, formatPromptTooLargeError, parseGitHubRemote } from "./github.shared"
+
+export const GithubInstallCommand = effectCmd({
+  command: "install",
+  describe: "install the GitHub agent",
+  handler: () =>
+    Effect.gen(function* () {
+      const { githubInstall } = yield* Effect.promise(() => import("./github.handler"))
+      return yield* githubInstall()
+    }),
+})
+
+export const GithubRunCommand = effectCmd({
+  command: "run",
+  describe: "run the GitHub agent",
+  builder: (yargs) =>
+    yargs
+      .option("event", {
+        type: "string",
+        describe: "GitHub mock event to run the agent for",
+      })
+      .option("token", {
+        type: "string",
+        describe: "GitHub personal access token (github_pat_********)",
+      }),
+  handler: (args) =>
+    Effect.gen(function* () {
+      const { githubRun } = yield* Effect.promise(() => import("./github.handler"))
+      return yield* githubRun(args)
+    }),
+})
+
+export const GithubCommand = cmd({
+  command: "github",
+  describe: "manage GitHub agent",
+  builder: (yargs) => yargs.command(GithubInstallCommand).command(GithubRunCommand).demandCommand(),
+  async handler() {},
+})

package/src/cli/cmd/import.ts

@@ -0,0 +1,224 @@
+import type { Session as SDKSession, Message, Part } from "@rimurucode-ai/sdk/v2"
+import { SessionV1 } from "@rimurucode-ai/core/v1/session"
+import { Session } from "@/session/session"
+import { MessageV2 } from "../../session/message-v2"
+import { CliError, effectCmd } from "../effect-cmd"
+import { Database } from "@rimurucode-ai/core/database/database"
+import { SessionTable, MessageTable, PartTable } from "@rimurucode-ai/core/session/sql"
+import { InstanceRef } from "@/effect/instance-ref"
+import { ShareNext } from "@/share/share-next"
+import { EOL } from "os"
+import path from "path"
+import { FSUtil } from "@rimurucode-ai/core/fs-util"
+import { Effect, Schema } from "effect"
+import type { InstanceContext } from "@/project/instance-context"
+
+const decodeMessageInfo = Schema.decodeUnknownSync(SessionV1.Info)
+const decodePart = Schema.decodeUnknownSync(SessionV1.Part)
+
+/** Discriminated union returned by the ShareNext API (GET /api/shares/:id/data) */
+export type ShareData =
+  | { type: "session"; data: SDKSession }
+  | { type: "message"; data: Message }
+  | { type: "part"; data: Part }
+  | { type: "session_diff"; data: unknown }
+  | { type: "model"; data: unknown }
+
+/** Extract share ID from a share URL like https://opncd.ai/share/abc123 */
+export function parseShareUrl(url: string): string | null {
+  const match = url.match(/^https?:\/\/[^/]+\/share\/([a-zA-Z0-9_-]+)$/)
+  return match ? match[1] : null
+}
+
+export function shouldAttachShareAuthHeaders(shareUrl: string, accountBaseUrl: string): boolean {
+  try {
+    return new URL(shareUrl).origin === new URL(accountBaseUrl).origin
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Transform ShareNext API response (flat array) into the nested structure for local file storage.
+ *
+ * The API returns a flat array: [session, message, message, part, part, ...]
+ * Local storage expects: { info: session, messages: [{ info: message, parts: [part, ...] }, ...] }
+ *
+ * This groups parts by their messageID to reconstruct the hierarchy before writing to disk.
+ */
+export function transformShareData(shareData: ShareData[]): {
+  info: SDKSession
+  messages: Array<{ info: Message; parts: Part[] }>
+} | null {
+  const sessionItem = shareData.find((d) => d.type === "session")
+  if (!sessionItem) return null
+
+  const messageMap = new Map<string, Message>()
+  const partMap = new Map<string, Part[]>()
+
+  for (const item of shareData) {
+    if (item.type === "message") {
+      messageMap.set(item.data.id, item.data)
+    } else if (item.type === "part") {
+      if (!partMap.has(item.data.messageID)) {
+        partMap.set(item.data.messageID, [])
+      }
+      partMap.get(item.data.messageID)!.push(item.data)
+    }
+  }
+
+  if (messageMap.size === 0) return null
+
+  return {
+    info: sessionItem.data,
+    messages: Array.from(messageMap.values()).map((msg) => ({
+      info: msg,
+      parts: partMap.get(msg.id) ?? [],
+    })),
+  }
+}
+
+type ExportData = { info: SDKSession; messages: Array<{ info: Message; parts: Part[] }> }
+
+export const ImportCommand = effectCmd({
+  command: "import <file>",
+  describe: "import session data from JSON file or URL",
+  builder: (yargs) =>
+    yargs.positional("file", {
+      describe: "path to JSON file or share URL",
+      type: "string",
+      demandOption: true,
+    }),
+  handler: Effect.fn("Cli.import")(function* (args) {
+    const ctx = yield* InstanceRef
+    if (!ctx) return yield* Effect.die("InstanceRef not provided")
+    return yield* runImport(args.file, ctx)
+  }),
+})
+
+const runImport = Effect.fn("Cli.import.body")(function* (file: string, ctx: InstanceContext) {
+  const share = yield* ShareNext.Service
+  const fs = yield* FSUtil.Service
+  const { db } = yield* Database.Service
+
+  let exportData: ExportData | undefined
+
+  const isUrl = file.startsWith("http://") || file.startsWith("https://")
+
+  if (isUrl) {
+    const slug = parseShareUrl(file)
+    if (!slug) {
+      const baseUrl = yield* Effect.orDie(share.url())
+      process.stdout.write(`Invalid URL format. Expected: ${baseUrl}/share/<slug>`)
+      process.stdout.write(EOL)
+      return
+    }
+
+    const baseUrl = new URL(file).origin
+    const req = yield* Effect.orDie(share.request())
+    const headers = shouldAttachShareAuthHeaders(file, req.baseUrl) ? req.headers : {}
+
+    const tryFetch = (url: string) =>
+      Effect.tryPromise({
+        try: () => fetch(url, { headers }),
+        catch: (e) =>
+          new CliError({
+            message: `Failed to fetch share data: ${e instanceof Error ? e.message : String(e)}`,
+          }),
+      })
+
+    const dataPath = req.api.data(slug)
+    let response = yield* tryFetch(`${baseUrl}${dataPath}`)
+
+    if (!response.ok && dataPath !== `/api/share/${slug}/data`) {
+      response = yield* tryFetch(`${baseUrl}/api/share/${slug}/data`)
+    }
+
+    if (!response.ok) {
+      process.stdout.write(`Failed to fetch share data: ${response.statusText}`)
+      process.stdout.write(EOL)
+      return
+    }
+
+    const shareData = yield* Effect.tryPromise({
+      try: () => response.json() as Promise<ShareData[]>,
+      catch: () => new CliError({ message: "Share data was not valid JSON" }),
+    })
+    const transformed = transformShareData(shareData)
+
+    if (!transformed) {
+      process.stdout.write(`Share not found or empty: ${slug}`)
+      process.stdout.write(EOL)
+      return
+    }
+
+    exportData = transformed
+  } else {
+    exportData = (yield* fs.readJson(file).pipe(Effect.orElseSucceed(() => undefined))) as
+      | NonNullable<typeof exportData>
+      | undefined
+    if (!exportData) {
+      process.stdout.write(`File not found: ${file}`)
+      process.stdout.write(EOL)
+      return
+    }
+  }
+
+  if (!exportData) {
+    process.stdout.write(`Failed to read session data`)
+    process.stdout.write(EOL)
+    return
+  }
+
+  const info = Schema.decodeUnknownSync(Session.Info)({
+    ...exportData.info,
+    projectID: ctx.project.id,
+    directory: ctx.directory,
+    path: path.relative(path.resolve(ctx.worktree), ctx.directory).replaceAll("\\", "/"),
+  }) as Session.Info
+  const row = Session.toRow(info)
+  yield* db
+    .insert(SessionTable)
+    .values(row)
+    .onConflictDoUpdate({
+      target: SessionTable.id,
+      set: { project_id: row.project_id, directory: row.directory, path: row.path },
+    })
+    .run()
+    .pipe(Effect.orDie)
+
+  for (const msg of exportData.messages) {
+    const msgInfo = decodeMessageInfo(msg.info) as SessionV1.Info
+    const { id, sessionID: _, ...msgData } = msgInfo
+    yield* db
+      .insert(MessageTable)
+      .values({
+        id,
+        session_id: row.id,
+        time_created: msgInfo.time?.created ?? Date.now(),
+        data: msgData as never,
+      })
+      .onConflictDoNothing()
+      .run()
+      .pipe(Effect.orDie)
+
+    for (const part of msg.parts) {
+      const partInfo = decodePart(part) as SessionV1.Part
+      const { id: partId, sessionID: _s, messageID, ...partData } = partInfo
+      yield* db
+        .insert(PartTable)
+        .values({
+          id: partId,
+          message_id: messageID,
+          session_id: row.id,
+          data: partData,
+        })
+        .onConflictDoNothing()
+        .run()
+        .pipe(Effect.orDie)
+    }
+  }
+
+  process.stdout.write(`Imported session: ${exportData.info.id}`)
+  process.stdout.write(EOL)
+})