@opendash-ai/cli 0.1.0-beta.1 → 0.1.0-beta.3

package/src/memory/reconcile.ts

@@ -1,144 +0,0 @@
-import * as fs from "fs/promises"
-import path from "path"
-import { Database, eq } from "../storage"
-import { Log } from "../util"
-import { MemoryFtsTable } from "./fts.sql"
-import { parsePath, parseCcPath, parseCcFrontmatterType, type MemoryLocator } from "./paths"
-
-const log = Log.create({ service: "memory.reconcile" })
-
-export async function walkMemoryDir(root: string): Promise<string[]> {
-  const out: string[] = []
-  async function recurse(dir: string) {
-    const entries = await fs.readdir(dir, { withFileTypes: true }).catch((e: NodeJS.ErrnoException) => {
-      if (e.code === "ENOENT") return [] as import("fs").Dirent[]
-      throw e
-    })
-    for (const entry of entries) {
-      const full = path.join(dir, entry.name)
-      if (entry.isDirectory()) await recurse(full)
-      else if (entry.isFile() && full.endsWith(".md")) out.push(full)
-    }
-  }
-  await recurse(root)
-  return out
-}
-
-// Walk <base>/<slug>/memory/**/*.md across every slug under <base>.
-// ENOENT on <base> returns []; missing memory subdirs are silently skipped.
-export async function walkCcRoot(base: string): Promise<string[]> {
-  const slugs = await fs.readdir(base, { withFileTypes: true }).catch((e: NodeJS.ErrnoException) => {
-    if (e.code === "ENOENT") return [] as import("fs").Dirent[]
-    throw e
-  })
-  const out: string[] = []
-  for (const entry of slugs) {
-    if (!entry.isDirectory()) continue
-    const memoryDir = path.join(base, entry.name, "memory")
-    const exists = await fs.stat(memoryDir).then(() => true).catch(() => false)
-    if (!exists) continue
-    const files = await walkMemoryDir(memoryDir)
-    for (const f of files) out.push(f)
-  }
-  return out
-}
-
-export async function indexFromDisk(
-  absPath: string,
-  loc: MemoryLocator,
-  bodyType: "mimo" | "cc",
-  oldFingerprint?: string,
-): Promise<"hit" | "updated" | "skipped"> {
-  const stat = await fs.stat(absPath).catch((e: NodeJS.ErrnoException) => {
-    if (e.code === "ENOENT") return null
-    throw e
-  })
-  if (!stat) return "skipped"
-  const fingerprint = `${stat.size}-${stat.mtimeMs}`
-  if (oldFingerprint === fingerprint) return "hit"
-
-  const body = await Bun.file(absPath).text()
-
-  // For CC files, derive type from frontmatter; mimo files keep loc.type from path.
-  const finalType =
-    bodyType === "cc" ? (parseCcFrontmatterType(body) ?? "free") : loc.type
-
-  Database.use((db) =>
-    db
-      .insert(MemoryFtsTable)
-      .values({
-        path: absPath,
-        scope: loc.scope,
-        scope_id: loc.scope_id,
-        type: finalType,
-        body,
-        fingerprint,
-        last_indexed_at: Date.now(),
-      })
-      .onConflictDoUpdate({
-        target: MemoryFtsTable.path,
-        set: {
-          scope: loc.scope,
-          scope_id: loc.scope_id,
-          type: finalType,
-          body,
-          fingerprint,
-          last_indexed_at: Date.now(),
-        },
-      })
-      .run(),
-  )
-  return "updated"
-}
-
-export async function reconcileMemory(
-  roots: { mimo: string; cc?: string },
-): Promise<{ indexed: number; pruned: number }> {
-  // Collect disk paths from BOTH roots before pruning. If we pruned per-root,
-  // enabling CC indexing on a fresh run would prune all mimo rows (and vice
-  // versa) because each walk's set is missing the other root's paths.
-  const mimoFiles = new Set(await walkMemoryDir(roots.mimo))
-  const ccFiles = roots.cc ? new Set(await walkCcRoot(roots.cc)) : new Set<string>()
-  const diskPaths = new Set<string>([...mimoFiles, ...ccFiles])
-
-  const indexed = new Map<string, string>(
-    Database.use((db) =>
-      db
-        .select({ path: MemoryFtsTable.path, fingerprint: MemoryFtsTable.fingerprint })
-        .from(MemoryFtsTable)
-        .all(),
-    ).map((r) => [r.path, r.fingerprint]),
-  )
-
-  // Direction B: prune dead FTS rows (any path not in either walk).
-  let pruned = 0
-  for (const p of indexed.keys()) {
-    if (!diskPaths.has(p)) {
-      Database.use((db) => db.delete(MemoryFtsTable).where(eq(MemoryFtsTable.path, p)).run())
-      pruned++
-    }
-  }
-
-  // Direction A: index disk files. Pick parser by which walk produced the path.
-  let indexedCount = 0
-  for (const p of mimoFiles) {
-    const loc = parsePath(p)
-    if (!loc) {
-      log.warn("path outside memory layout, skipping", { path: p })
-      continue
-    }
-    const result = await indexFromDisk(p, loc, "mimo", indexed.get(p))
-    if (result === "updated") indexedCount++
-  }
-  for (const p of ccFiles) {
-    const loc = parseCcPath(p)
-    if (!loc) {
-      log.warn("CC path failed to parse, skipping", { path: p })
-      continue
-    }
-    const result = await indexFromDisk(p, loc, "cc", indexed.get(p))
-    if (result === "updated") indexedCount++
-  }
-
-  return { indexed: indexedCount, pruned }
-}

package/src/memory/service.ts

@@ -1,144 +0,0 @@
-import { Context, Effect, Layer } from "effect"
-import path from "path"
-import os from "os"
-import { Global } from "../global"
-import { Database } from "../storage"
-import { Config } from "../config"
-import { reconcileMemory } from "./reconcile"
-import { buildFtsQuery } from "./fts-query"
-
-type SearchRow = {
-  path: string
-  scope: string
-  scope_id: string
-  type: string
-  snippet: string
-  score: number
-}
-
-export interface Interface {
-  readonly root: () => Effect.Effect<string>
-  readonly reconcile: () => Effect.Effect<{ indexed: number; pruned: number }>
-  readonly search: (input: {
-    query: string
-    scope?: string
-    scope_id?: string
-    type?: string
-    limit?: number
-  }) => Effect.Effect<
-    Array<{ path: string; snippet: string; score: number; scope: string; scope_id: string; type: string }>
-  >
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opendash/Memory") {}
-
-export const layer: Layer.Layer<Service, never, Config.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const config = yield* Config.Service
-    const root = path.join(Global.Path.data, "memory")
-    const ccBase = path.join(os.homedir(), ".claude", "projects")
-
-    const rootEff = Effect.fn("Memory.root")(function* () {
-      return root
-    })
-
-    const reconcile = Effect.fn("Memory.reconcile")(function* () {
-      const cfg = yield* config.get()
-      const cc = cfg.memory?.cc_index ? ccBase : undefined
-      return yield* Effect.promise(() => reconcileMemory({ mimo: root, cc }))
-    })
-
-    const search = Effect.fn("Memory.search")(function* (input: {
-      query: string
-      scope?: string
-      scope_id?: string
-      type?: string
-      limit?: number
-    }) {
-      // Lazy reconcile before search (covers off-tool writes); honour config flag.
-      const cfg = yield* config.get()
-      if (cfg.checkpoint?.memory_reconcile_on_search ?? true) {
-        const cc = cfg.memory?.cc_index ? ccBase : undefined
-        yield* Effect.promise(() => reconcileMemory({ mimo: root, cc }))
-      }
-
-      const limit = input.limit ?? 10
-      // Build a token-level FTS5 query: punctuation becomes separators,
-      // each alphanumeric run becomes a phrase-quoted literal, OR-joined.
-      // See packages/opencode/src/memory/fts-query.ts for the rationale.
-      const ftsQuery = buildFtsQuery(input.query)
-      if (!ftsQuery) return []
-
-      // OR-join means a doc matching only a common word (e.g. every
-      // checkpoint.md matches "checkpoint") still matches, but BM25 ranks it
-      // far below a doc matching several rare query words. We drop the
-      // common-word noise with a RELATIVE floor: keep results scoring at
-      // least `ratio` of the top hit's score. Relative (not absolute)
-      // because BM25 magnitudes are corpus-size-dependent — in a tiny corpus
-      // every score collapses toward 0 (low IDF), so any fixed absolute floor
-      // would wrongly wipe real hits. The #1 result is ALWAYS kept (a match
-      // is a match even when BM25 can't discriminate). Default 0.15.
-      // Configurable; 0 disables (keep all matches).
-      const floorRatio = cfg.checkpoint?.memory_search_score_floor ?? 0.15
-
-      // Construct WHERE clauses for scope/scope_id/type filtering
-      const conditions: string[] = []
-      const params: string[] = []
-      if (input.scope) {
-        conditions.push("memory_fts.scope = ?")
-        params.push(input.scope)
-      }
-      if (input.scope_id) {
-        conditions.push("memory_fts.scope_id = ?")
-        params.push(input.scope_id)
-      }
-      if (input.type) {
-        conditions.push("memory_fts.type = ?")
-        params.push(input.type)
-      }
-      const whereClause = conditions.length > 0 ? `AND ${conditions.join(" AND ")}` : ""
-
-      const sql = `
-        SELECT memory_fts.path, memory_fts.scope, memory_fts.scope_id, memory_fts.type,
-               snippet(memory_fts_idx, 0, '<<', '>>', '...', 32) AS snippet,
-               bm25(memory_fts_idx) AS score
-        FROM memory_fts_idx
-        JOIN memory_fts ON memory_fts.id = memory_fts_idx.rowid
-        WHERE memory_fts_idx MATCH ?
-        ${whereClause}
-        ORDER BY score
-        LIMIT ?
-      `
-
-      // Over-fetch (3x, capped) so the relative floor can trim common-word
-      // noise without starving the list when there ARE enough real hits.
-      const fetchLimit = Math.min(limit * 3, 50)
-      const rows = Database.Client().$client.query(sql).all(ftsQuery, ...params, fetchLimit) as SearchRow[]
-
-      // FTS5 bm25() returns lower = better; convert to higher = better for caller
-      const mapped = rows.map((r) => ({
-        path: r.path,
-        snippet: r.snippet,
-        score: -r.score,
-        scope: r.scope,
-        scope_id: r.scope_id,
-        type: r.type,
-      }))
-      if (mapped.length === 0) return []
-      // Rows are ORDER BY score (best first), so mapped[0] is the top hit.
-      // Always keep it; drop trailing rows below `floorRatio` of its score.
-      const topScore = mapped[0].score
-      const cutoff = floorRatio > 0 ? topScore * floorRatio : -Infinity
-      return mapped.filter((r, i) => i === 0 || r.score >= cutoff).slice(0, limit)
-    })
-
-    return Service.of({
-      root: rootEff,
-      reconcile,
-      search,
-    })
-  }),
-)
-
-export const defaultLayer = Layer.suspend(() => layer.pipe(Layer.provide(Config.defaultLayer)))

package/src/metrics/client.ts

@@ -1,40 +0,0 @@
-export const ENDPOINT = "https://tracking.miui.com/track/v4/o"
-export const APP_ID = "31000402765"
-
-export type EventType = "model_call" | "tool_call" | "agent_request" | (string & {})
-
-export type Header = {
-  event: EventType
-  app_id: string
-  instance_id: string
-  instance_id_type: "uuid"
-  uid?: string
-  uid_type?: "session_id"
-  e_ts: number
-}
-
-export function buildHeader(event: EventType, sessionID?: string): Header {
-  const header: Header = {
-    event,
-    app_id: APP_ID,
-    instance_id: crypto.randomUUID(),
-    instance_id_type: "uuid",
-    e_ts: Date.now(),
-  }
-  if (sessionID) {
-    header.uid = sessionID
-    header.uid_type = "session_id"
-  }
-  return header
-}
-
-export type Envelope = { H: Header; B: Record<string, unknown> }
-
-export async function postEvents(payload: Envelope[]): Promise<void> {
-  await fetch(ENDPOINT, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(payload),
-    signal: AbortSignal.timeout(60000),
-  }).catch(() => {})
-}

package/src/metrics/event.ts

@@ -1,43 +0,0 @@
-import z from "zod"
-import { BusEvent } from "@/bus/bus-event"
-
-export const ModelCall = BusEvent.define(
-  "metrics.model_call",
-  z.object({
-    sessionID: z.string(),
-    finish_reason: z.string(),
-    ttft_ms: z.number().optional(),
-    latency_ms: z.number(),
-    cached_read_tokens: z.number(),
-    model_id: z.string(),
-    provider: z.string(),
-    total_tokens_in: z.number(),
-    total_tokens_out: z.number(),
-  }),
-)
-
-export const ToolCall = BusEvent.define(
-  "metrics.tool_call",
-  z.object({
-    sessionID: z.string(),
-    tool_name: z.string(),
-    input_bytes: z.number(),
-    output_bytes: z.number(),
-    tool_call_id: z.string(),
-    tool_call_status: z.enum(["success", "error", "cancelled"]),
-  }),
-)
-
-export const AgentRequest = BusEvent.define(
-  "metrics.agent_request",
-  z.object({
-    sessionID: z.string(),
-    phase: z.string(),
-    task_type: z.string(),
-    surface: z.string(),
-    total_tokens_in: z.number(),
-    total_tokens_out: z.number(),
-    files_changed: z.number(),
-    validation_status: z.string(),
-  }),
-)

package/src/metrics/index.ts

@@ -1,5 +0,0 @@
-export { subscribe } from "./subscriber"
-export { getInstallationID } from "./installation"
-export { ModelCall, ToolCall, AgentRequest } from "./event"
-export { jsonByteLength } from "./util"
-export * as Metrics from "."

package/src/metrics/installation.ts

@@ -1,18 +0,0 @@
-import path from "path"
-import { Global } from "@/global"
-import { Filesystem } from "@/util"
-
-let cached: string | undefined
-
-export async function getInstallationID(): Promise<string> {
-  if (cached) return cached
-  const file = path.join(Global.Path.data, "installation_id")
-  const existing = await Filesystem.readText(file).catch(() => undefined)
-  if (existing && existing.trim()) {
-    cached = existing.trim()
-    return cached
-  }
-  cached = crypto.randomUUID()
-  await Filesystem.write(file, cached)
-  return cached
-}

package/src/metrics/subscriber.ts

@@ -1,58 +0,0 @@
-import { Effect } from "effect"
-import { Bus } from "@/bus"
-import { Flag } from "@/flag/flag"
-import { ModelCall, ToolCall, AgentRequest } from "./event"
-import { buildHeader, postEvents, type EventType } from "./client"
-import { getInstallationID } from "./installation"
-
-function send(event: EventType, sessionID: string, body: Record<string, unknown>) {
-  return postEvents([{ H: buildHeader(event, sessionID), B: body }])
-}
-
-export const subscribe = Effect.fn("Metrics.subscribe")(function* () {
-  if (!Flag.OPENDASH_ENABLE_ANALYSIS) return
-  // Touch installation_id so the file exists on first launch even before any
-  // event fires. The value is intentionally NOT included in wire payloads —
-  // H.instance_id is a fresh random UUID per report.
-  yield* Effect.promise(() => getInstallationID().catch(() => ""))
-
-  yield* Bus.Service.use((svc) =>
-    Effect.all([
-      svc.subscribeCallback(ModelCall, (e) => {
-        const p = e.properties
-        return send("model_call", p.sessionID, {
-          finish_reason: p.finish_reason,
-          ttft_ms: p.ttft_ms,
-          latency_ms: p.latency_ms,
-          cached_read_tokens: p.cached_read_tokens,
-          model_id: p.model_id,
-          provider: p.provider,
-          total_tokens_in: p.total_tokens_in,
-          total_tokens_out: p.total_tokens_out,
-        })
-      }),
-      svc.subscribeCallback(ToolCall, (e) => {
-        const p = e.properties
-        return send("tool_call", p.sessionID, {
-          tool_name: p.tool_name,
-          input_bytes: p.input_bytes,
-          output_bytes: p.output_bytes,
-          tool_call_id: p.tool_call_id,
-          tool_call_status: p.tool_call_status,
-        })
-      }),
-      svc.subscribeCallback(AgentRequest, (e) => {
-        const p = e.properties
-        return send("agent_request", p.sessionID, {
-          phase: p.phase,
-          task_type: p.task_type,
-          surface: p.surface,
-          total_tokens_in: p.total_tokens_in,
-          total_tokens_out: p.total_tokens_out,
-          files_changed: p.files_changed,
-          validation_status: p.validation_status,
-        })
-      }),
-    ]),
-  )
-})

package/src/metrics/util.ts

@@ -1,9 +0,0 @@
-export function jsonByteLength(value: unknown): number {
-  try {
-    const str = JSON.stringify(value)
-    if (typeof str !== "string") return 0
-    return Buffer.byteLength(str, "utf8")
-  } catch {
-    return 0
-  }
-}

package/src/node.ts

@@ -1,6 +0,0 @@
-export { Config } from "./config"
-export { Server } from "./server/server"
-export { bootstrap } from "./cli/bootstrap"
-export { Log } from "./util"
-export { Database } from "./storage"
-export { JsonMigration } from "./storage"