anymous 1.3.0 → 1.3.2

package/src/cli/cmd/serve.ts

@@ -1,24 +0,0 @@
-import { Effect } from "effect"
-import { effectCmd } from "../effect-cmd"
-import { withNetworkOptions, resolveNetworkOptions } from "../network"
-import { Flag } from "@anymous-ai/core/flag/flag"
-
-export const ServeCommand = effectCmd({
-  command: "serve",
-  builder: (yargs) => withNetworkOptions(yargs),
-  describe: "starts a headless Anymous server",
-  // Server loads instances per-request via x-anymous-directory header — no
-  // need for an ambient project InstanceContext at startup.
-  instance: false,
-  handler: Effect.fn("Cli.serve")(function* (args) {
-    const { Server } = yield* Effect.promise(() => import("../../server/server"))
-    if (!Flag.ANYMOUS_SERVER_PASSWORD) {
-      console.log("Warning: ANYMOUS_SERVER_PASSWORD is not set; server is unsecured.")
-    }
-    const opts = yield* resolveNetworkOptions(args)
-    const server = yield* Effect.promise(() => Server.listen(opts))
-    console.log(`Anymous server listening on http://${server.hostname}:${server.port}`)
-
-    yield* Effect.never
-  }),
-})

package/src/cli/cmd/session.ts

@@ -1,147 +0,0 @@
-import type { Argv } from "yargs"
-import { Effect } from "effect"
-import { cmd } from "./cmd"
-import { effectCmd, fail } from "../effect-cmd"
-import { Session } from "@/session/session"
-import { SessionID } from "../../session/schema"
-import { UI } from "../ui"
-import { Locale } from "@/util/locale"
-import { Flag } from "@anymous-ai/core/flag/flag"
-import { Filesystem } from "@/util/filesystem"
-import { Process } from "@/util/process"
-import { NotFoundError } from "@/storage/storage"
-import { EOL } from "os"
-import path from "path"
-import { which } from "@anymous-ai/core/util/which"
-
-function pagerCmd(): string[] {
-  const lessOptions = ["-R", "-S"]
-  if (process.platform !== "win32") {
-    return ["less", ...lessOptions]
-  }
-
-  // user could have less installed via other options
-  const lessOnPath = which("less")
-  if (lessOnPath) {
-    if (Filesystem.stat(lessOnPath)?.size) return [lessOnPath, ...lessOptions]
-  }
-
-  if (Flag.ANYMOUS_GIT_BASH_PATH) {
-    const less = path.join(Flag.ANYMOUS_GIT_BASH_PATH, "..", "..", "usr", "bin", "less.exe")
-    if (Filesystem.stat(less)?.size) return [less, ...lessOptions]
-  }
-
-  const git = which("git")
-  if (git) {
-    const less = path.join(git, "..", "..", "usr", "bin", "less.exe")
-    if (Filesystem.stat(less)?.size) return [less, ...lessOptions]
-  }
-
-  // Fall back to Windows built-in more (via cmd.exe)
-  return ["cmd", "/c", "more"]
-}
-
-export const SessionCommand = cmd({
-  command: "session",
-  describe: "manage sessions",
-  builder: (yargs: Argv) => yargs.command(SessionListCommand).command(SessionDeleteCommand).demandCommand(),
-  async handler() {},
-})
-
-export const SessionDeleteCommand = effectCmd({
-  command: "delete <sessionID>",
-  describe: "delete a session",
-  builder: (yargs) =>
-    yargs.positional("sessionID", {
-      describe: "session ID to delete",
-      type: "string",
-      demandOption: true,
-    }),
-  handler: Effect.fn("Cli.session.delete")(function* (args) {
-    const svc = yield* Session.Service
-    const sessionID = SessionID.make(args.sessionID)
-    yield* svc
-      .remove(sessionID)
-      .pipe(Effect.catchIf(NotFoundError.isInstance, () => fail(`Session not found: ${args.sessionID}`)))
-    UI.println(UI.Style.TEXT_SUCCESS_BOLD + `Session ${args.sessionID} deleted` + UI.Style.TEXT_NORMAL)
-  }),
-})
-
-export const SessionListCommand = effectCmd({
-  command: "list",
-  describe: "list sessions",
-  builder: (yargs) =>
-    yargs
-      .option("max-count", {
-        alias: "n",
-        describe: "limit to N most recent sessions",
-        type: "number",
-      })
-      .option("format", {
-        describe: "output format",
-        type: "string",
-        choices: ["table", "json"],
-        default: "table",
-      }),
-  handler: Effect.fn("Cli.session.list")(function* (args) {
-    const sessions = yield* Session.Service.use((svc) => svc.list({ roots: true, limit: args.maxCount }))
-
-    if (sessions.length === 0) return
-
-    const output = args.format === "json" ? formatSessionJSON(sessions) : formatSessionTable(sessions)
-
-    const shouldPaginate = process.stdout.isTTY && !args.maxCount && args.format === "table"
-
-    if (shouldPaginate) {
-      yield* Effect.promise(async () => {
-        const proc = Process.spawn(pagerCmd(), {
-          stdin: "pipe",
-          stdout: "inherit",
-          stderr: "inherit",
-        })
-
-        if (!proc.stdin) {
-          console.log(output)
-          return
-        }
-
-        proc.stdin.write(output)
-        proc.stdin.end()
-        await proc.exited
-      })
-    } else {
-      console.log(output)
-    }
-  }),
-})
-
-function formatSessionTable(sessions: Session.Info[]): string {
-  const lines: string[] = []
-
-  const maxIdWidth = Math.max(20, ...sessions.map((s) => s.id.length))
-  const maxTitleWidth = Math.max(25, ...sessions.map((s) => s.title.length))
-
-  const header = `Session ID${" ".repeat(maxIdWidth - 10)}  Title${" ".repeat(maxTitleWidth - 5)}  Updated`
-  lines.push(header)
-  lines.push("─".repeat(header.length))
-  for (const session of sessions) {
-    const truncatedTitle = Locale.truncate(session.title, maxTitleWidth)
-    const timeStr = Locale.todayTimeOrDateTime(session.time.updated)
-    const line = `${session.id.padEnd(maxIdWidth)}  ${truncatedTitle.padEnd(maxTitleWidth)}  ${timeStr}`
-    lines.push(line)
-  }
-
-  return lines.join(EOL)
-}
-
-function formatSessionJSON(sessions: Session.Info[]): string {
-  const jsonData = sessions.map((session) => ({
-    id: session.id,
-    title: session.title,
-    updated: session.time.updated,
-    created: session.time.created,
-    projectId: session.projectID,
-    directory: session.directory,
-  }))
-  return JSON.stringify(jsonData, null, 2)
-}

package/src/cli/cmd/stats.ts

@@ -1,393 +0,0 @@
-import { Effect } from "effect"
-import { effectCmd } from "../effect-cmd"
-import { Session } from "@/session/session"
-import { NotFoundError } from "@/storage/storage"
-import { Database } from "@anymous-ai/core/database/database"
-import { SessionTable } from "@anymous-ai/core/session/sql"
-import type { Project } from "@/project/project"
-import { InstanceRef } from "@/effect/instance-ref"
-
-interface SessionStats {
-  totalSessions: number
-  totalMessages: number
-  totalCost: number
-  totalTokens: {
-    input: number
-    output: number
-    reasoning: number
-    cache: {
-      read: number
-      write: number
-    }
-  }
-  toolUsage: Record<string, number>
-  modelUsage: Record<
-    string,
-    {
-      messages: number
-      tokens: {
-        input: number
-        output: number
-        cache: {
-          read: number
-          write: number
-        }
-      }
-      cost: number
-    }
-  >
-  dateRange: {
-    earliest: number
-    latest: number
-  }
-  days: number
-  costPerDay: number
-  tokensPerSession: number
-  medianTokensPerSession: number
-}
-
-export const StatsCommand = effectCmd({
-  command: "stats",
-  describe: "show token usage and cost statistics",
-  builder: (yargs) =>
-    yargs
-      .option("days", {
-        describe: "show stats for the last N days (default: all time)",
-        type: "number",
-      })
-      .option("tools", {
-        describe: "number of tools to show (default: all)",
-        type: "number",
-      })
-      .option("models", {
-        describe: "show model statistics (default: hidden). Pass a number to show top N, otherwise shows all",
-      })
-      .option("project", {
-        describe: "filter by project (default: all projects, empty string: current project)",
-        type: "string",
-      }),
-  handler: Effect.fn("Cli.stats")(function* (args) {
-    const ctx = yield* InstanceRef
-    if (!ctx) return
-    const stats = yield* aggregateSessionStats(args.days, args.project, ctx.project)
-    let modelLimit: number | undefined
-    if (args.models === true) {
-      modelLimit = Infinity
-    } else if (typeof args.models === "number") {
-      modelLimit = args.models
-    }
-    displayStats(stats, args.tools, modelLimit)
-  }),
-})
-
-const getAllSessions = Effect.fnUntraced(function* () {
-  const { db } = yield* Database.Service
-  return (yield* db.select().from(SessionTable).all().pipe(Effect.orDie)).map((row) => Session.fromRow(row))
-})
-
-const aggregateSessionStats = Effect.fn("Cli.stats.aggregate")(function* (
-  days?: number,
-  projectFilter?: string,
-  currentProject?: Project.Info,
-) {
-  const svc = yield* Session.Service
-  const sessions = yield* getAllSessions()
-  const MS_IN_DAY = 24 * 60 * 60 * 1000
-
-  const cutoffTime = (() => {
-    if (days === undefined) return 0
-    if (days === 0) {
-      const now = new Date()
-      now.setHours(0, 0, 0, 0)
-      return now.getTime()
-    }
-    return Date.now() - days * MS_IN_DAY
-  })()
-
-  const windowDays = (() => {
-    if (days === undefined) return
-    if (days === 0) return 1
-    return days
-  })()
-
-  let filteredSessions = cutoffTime > 0 ? sessions.filter((session) => session.time.updated >= cutoffTime) : sessions
-
-  if (projectFilter !== undefined) {
-    if (projectFilter === "") {
-      if (!currentProject) throw new Error("currentProject required when projectFilter is empty string")
-      filteredSessions = filteredSessions.filter((session) => session.projectID === currentProject.id)
-    } else {
-      filteredSessions = filteredSessions.filter((session) => session.projectID === projectFilter)
-    }
-  }
-
-  const stats: SessionStats = {
-    totalSessions: filteredSessions.length,
-    totalMessages: 0,
-    totalCost: 0,
-    totalTokens: {
-      input: 0,
-      output: 0,
-      reasoning: 0,
-      cache: {
-        read: 0,
-        write: 0,
-      },
-    },
-    toolUsage: {},
-    modelUsage: {},
-    dateRange: {
-      earliest: Date.now(),
-      latest: Date.now(),
-    },
-    days: 0,
-    costPerDay: 0,
-    tokensPerSession: 0,
-    medianTokensPerSession: 0,
-  }
-
-  if (filteredSessions.length > 1000) {
-    console.log(`Large dataset detected (${filteredSessions.length} sessions). This may take a while...`)
-  }
-
-  if (filteredSessions.length === 0) {
-    stats.days = windowDays ?? 0
-    return stats
-  }
-
-  let earliestTime = Date.now()
-  let latestTime = 0
-
-  const sessionTotalTokens: number[] = []
-
-  const results = yield* Effect.forEach(
-    filteredSessions,
-    (session) =>
-      Effect.gen(function* () {
-        const messages = yield* svc
-          .messages({ sessionID: session.id })
-          .pipe(Effect.catchIf(NotFoundError.isInstance, () => Effect.succeed([])))
-
-        const sessionCost = session.cost ?? 0
-        const sessionTokens = session.tokens ?? { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }
-        let sessionToolUsage: Record<string, number> = {}
-        let sessionModelUsage: Record<
-          string,
-          {
-            messages: number
-            tokens: { input: number; output: number; cache: { read: number; write: number } }
-            cost: number
-          }
-        > = {}
-
-        for (const message of messages) {
-          if (message.info.role === "assistant") {
-            const modelKey = `${message.info.providerID}/${message.info.modelID}`
-            if (!sessionModelUsage[modelKey]) {
-              sessionModelUsage[modelKey] = {
-                messages: 0,
-                tokens: { input: 0, output: 0, cache: { read: 0, write: 0 } },
-                cost: 0,
-              }
-            }
-            sessionModelUsage[modelKey].messages++
-            sessionModelUsage[modelKey].cost += message.info.cost || 0
-
-            if (message.info.tokens) {
-              sessionModelUsage[modelKey].tokens.input += message.info.tokens.input || 0
-              sessionModelUsage[modelKey].tokens.output +=
-                (message.info.tokens.output || 0) + (message.info.tokens.reasoning || 0)
-              sessionModelUsage[modelKey].tokens.cache.read += message.info.tokens.cache?.read || 0
-              sessionModelUsage[modelKey].tokens.cache.write += message.info.tokens.cache?.write || 0
-            }
-          }
-
-          for (const part of message.parts) {
-            if (part.type === "tool" && part.tool) {
-              sessionToolUsage[part.tool] = (sessionToolUsage[part.tool] || 0) + 1
-            }
-          }
-        }
-
-        return {
-          messageCount: messages.length,
-          sessionCost,
-          sessionTokens,
-          sessionTotalTokens:
-            sessionTokens.input +
-            sessionTokens.output +
-            sessionTokens.reasoning +
-            sessionTokens.cache.read +
-            sessionTokens.cache.write,
-          sessionToolUsage,
-          sessionModelUsage,
-          earliestTime: cutoffTime > 0 ? session.time.updated : session.time.created,
-          latestTime: session.time.updated,
-        }
-      }),
-    { concurrency: 20 },
-  )
-
-  for (const result of results) {
-    earliestTime = Math.min(earliestTime, result.earliestTime)
-    latestTime = Math.max(latestTime, result.latestTime)
-    sessionTotalTokens.push(result.sessionTotalTokens)
-
-    stats.totalMessages += result.messageCount
-    stats.totalCost += result.sessionCost
-    stats.totalTokens.input += result.sessionTokens.input
-    stats.totalTokens.output += result.sessionTokens.output
-    stats.totalTokens.reasoning += result.sessionTokens.reasoning
-    stats.totalTokens.cache.read += result.sessionTokens.cache.read
-    stats.totalTokens.cache.write += result.sessionTokens.cache.write
-
-    for (const [tool, count] of Object.entries(result.sessionToolUsage)) {
-      stats.toolUsage[tool] = (stats.toolUsage[tool] || 0) + count
-    }
-
-    for (const [model, usage] of Object.entries(result.sessionModelUsage)) {
-      if (!stats.modelUsage[model]) {
-        stats.modelUsage[model] = {
-          messages: 0,
-          tokens: { input: 0, output: 0, cache: { read: 0, write: 0 } },
-          cost: 0,
-        }
-      }
-      stats.modelUsage[model].messages += usage.messages
-      stats.modelUsage[model].tokens.input += usage.tokens.input
-      stats.modelUsage[model].tokens.output += usage.tokens.output
-      stats.modelUsage[model].tokens.cache.read += usage.tokens.cache.read
-      stats.modelUsage[model].tokens.cache.write += usage.tokens.cache.write
-      stats.modelUsage[model].cost += usage.cost
-    }
-  }
-
-  const rangeDays = Math.max(1, Math.ceil((latestTime - earliestTime) / MS_IN_DAY))
-  const effectiveDays = windowDays ?? rangeDays
-  stats.dateRange = {
-    earliest: earliestTime,
-    latest: latestTime,
-  }
-  stats.days = effectiveDays
-  stats.costPerDay = stats.totalCost / effectiveDays
-  const totalTokens =
-    stats.totalTokens.input +
-    stats.totalTokens.output +
-    stats.totalTokens.reasoning +
-    stats.totalTokens.cache.read +
-    stats.totalTokens.cache.write
-  stats.tokensPerSession = filteredSessions.length > 0 ? totalTokens / filteredSessions.length : 0
-  sessionTotalTokens.sort((a, b) => a - b)
-  const mid = Math.floor(sessionTotalTokens.length / 2)
-  stats.medianTokensPerSession =
-    sessionTotalTokens.length === 0
-      ? 0
-      : sessionTotalTokens.length % 2 === 0
-        ? (sessionTotalTokens[mid - 1] + sessionTotalTokens[mid]) / 2
-        : sessionTotalTokens[mid]
-
-  return stats
-})
-
-export function displayStats(stats: SessionStats, toolLimit?: number, modelLimit?: number) {
-  const width = 56
-
-  function renderRow(label: string, value: string): string {
-    const availableWidth = width - 1
-    const paddingNeeded = availableWidth - label.length - value.length
-    const padding = Math.max(0, paddingNeeded)
-    return `│${label}${" ".repeat(padding)}${value} │`
-  }
-
-  // Overview section
-  console.log("┌────────────────────────────────────────────────────────┐")
-  console.log("│                       OVERVIEW                         │")
-  console.log("├────────────────────────────────────────────────────────┤")
-  console.log(renderRow("Sessions", stats.totalSessions.toLocaleString()))
-  console.log(renderRow("Messages", stats.totalMessages.toLocaleString()))
-  console.log(renderRow("Days", stats.days.toString()))
-  console.log("└────────────────────────────────────────────────────────┘")
-  console.log()
-
-  // Cost & Tokens section
-  console.log("┌────────────────────────────────────────────────────────┐")
-  console.log("│                    COST & TOKENS                       │")
-  console.log("├────────────────────────────────────────────────────────┤")
-  const cost = isNaN(stats.totalCost) ? 0 : stats.totalCost
-  const costPerDay = isNaN(stats.costPerDay) ? 0 : stats.costPerDay
-  const tokensPerSession = isNaN(stats.tokensPerSession) ? 0 : stats.tokensPerSession
-  console.log(renderRow("Total Cost", `$${cost.toFixed(2)}`))
-  console.log(renderRow("Avg Cost/Day", `$${costPerDay.toFixed(2)}`))
-  console.log(renderRow("Avg Tokens/Session", formatNumber(Math.round(tokensPerSession))))
-  const medianTokensPerSession = isNaN(stats.medianTokensPerSession) ? 0 : stats.medianTokensPerSession
-  console.log(renderRow("Median Tokens/Session", formatNumber(Math.round(medianTokensPerSession))))
-  console.log(renderRow("Input", formatNumber(stats.totalTokens.input)))
-  console.log(renderRow("Output", formatNumber(stats.totalTokens.output)))
-  console.log(renderRow("Cache Read", formatNumber(stats.totalTokens.cache.read)))
-  console.log(renderRow("Cache Write", formatNumber(stats.totalTokens.cache.write)))
-  console.log("└────────────────────────────────────────────────────────┘")
-  console.log()
-
-  // Model Usage section
-  if (modelLimit !== undefined && Object.keys(stats.modelUsage).length > 0) {
-    const sortedModels = Object.entries(stats.modelUsage).sort(([, a], [, b]) => b.messages - a.messages)
-    const modelsToDisplay = modelLimit === Infinity ? sortedModels : sortedModels.slice(0, modelLimit)
-
-    console.log("┌────────────────────────────────────────────────────────┐")
-    console.log("│                      MODEL USAGE                       │")
-    console.log("├────────────────────────────────────────────────────────┤")
-
-    for (const [model, usage] of modelsToDisplay) {
-      console.log(`│ ${model.padEnd(54)} │`)
-      console.log(renderRow("  Messages", usage.messages.toLocaleString()))
-      console.log(renderRow("  Input Tokens", formatNumber(usage.tokens.input)))
-      console.log(renderRow("  Output Tokens", formatNumber(usage.tokens.output)))
-      console.log(renderRow("  Cache Read", formatNumber(usage.tokens.cache.read)))
-      console.log(renderRow("  Cache Write", formatNumber(usage.tokens.cache.write)))
-      console.log(renderRow("  Cost", `$${usage.cost.toFixed(4)}`))
-      console.log("├────────────────────────────────────────────────────────┤")
-    }
-    // Remove last separator and add bottom border
-    process.stdout.write("\x1B[1A") // Move up one line
-    console.log("└────────────────────────────────────────────────────────┘")
-  }
-  console.log()
-
-  // Tool Usage section
-  if (Object.keys(stats.toolUsage).length > 0) {
-    const sortedTools = Object.entries(stats.toolUsage).sort(([, a], [, b]) => b - a)
-    const toolsToDisplay = toolLimit ? sortedTools.slice(0, toolLimit) : sortedTools
-
-    console.log("┌────────────────────────────────────────────────────────┐")
-    console.log("│                      TOOL USAGE                        │")
-    console.log("├────────────────────────────────────────────────────────┤")
-
-    const maxCount = Math.max(...toolsToDisplay.map(([, count]) => count))
-    const totalToolUsage = Object.values(stats.toolUsage).reduce((a, b) => a + b, 0)
-
-    for (const [tool, count] of toolsToDisplay) {
-      const barLength = Math.max(1, Math.floor((count / maxCount) * 20))
-      const bar = "█".repeat(barLength)
-      const percentage = ((count / totalToolUsage) * 100).toFixed(1)
-
-      const maxToolLength = 18
-      const truncatedTool = tool.length > maxToolLength ? tool.substring(0, maxToolLength - 2) + ".." : tool
-      const toolName = truncatedTool.padEnd(maxToolLength)
-
-      const content = ` ${toolName} ${bar.padEnd(20)} ${count.toString().padStart(3)} (${percentage.padStart(4)}%)`
-      const padding = Math.max(0, width - content.length - 1)
-      console.log(`│${content}${" ".repeat(padding)} │`)
-    }
-    console.log("└────────────────────────────────────────────────────────┘")
-  }
-  console.log()
-}
-
-function formatNumber(num: number): string {
-  if (num >= 1000000) {
-    return (num / 1000000).toFixed(1) + "M"
-  } else if (num >= 1000) {
-    return (num / 1000).toFixed(1) + "K"
-  }
-  return num.toString()
-}