@sleepy-ai/cli 0.1.6 → 0.1.7

package/src/project/project-id.ts

@@ -1,48 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import * as crypto from "crypto"
-import { ProjectID } from "./schema"
-
-export function resolveMainGitDir(startDir: string): string | null {
-  let dir = path.resolve(startDir)
-  while (true) {
-    const candidate = path.join(dir, ".git")
-    if (fs.existsSync(candidate)) {
-      const stat = fs.statSync(candidate)
-      if (stat.isDirectory()) return candidate
-      const content = fs.readFileSync(candidate, "utf-8").trim()
-      const match = content.match(/^gitdir:\s*(.+)$/)
-      if (!match) return null
-      return path.resolve(match[1], "../..")
-    }
-    const parent = path.dirname(dir)
-    if (parent === dir) return null
-    dir = parent
-  }
-}
-
-function readFileTrimmedOrNull(p: string): string | null {
-  if (!fs.existsSync(p)) return null
-  const text = fs.readFileSync(p, "utf-8").trim()
-  return text || null
-}
-
-export function resolveProjectId(workingDir: string): ProjectID {
-  const mainGit = resolveMainGitDir(workingDir)
-
-  if (mainGit) {
-    const idFile = path.join(mainGit, "sleepycode-project-id")
-    const cached = readFileTrimmedOrNull(idFile)
-    if (cached) return ProjectID.make(cached)
-    const newId = crypto.randomUUID()
-    fs.writeFileSync(idFile, newId)
-    return ProjectID.make(newId)
-  }
-
-  const localFile = path.join(workingDir, ".sleepycode-project-id")
-  const cached = readFileTrimmedOrNull(localFile)
-  if (cached) return ProjectID.make(cached)
-  const newId = crypto.randomUUID()
-  fs.writeFileSync(localFile, newId)
-  return ProjectID.make(newId)
-}

package/src/project/project.sql.ts

@@ -1,16 +0,0 @@
-import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core"
-import { Timestamps } from "../storage/schema.sql"
-import type { ProjectID } from "./schema"
-
-export const ProjectTable = sqliteTable("project", {
-  id: text().$type<ProjectID>().primaryKey(),
-  worktree: text().notNull(),
-  vcs: text(),
-  name: text(),
-  icon_url: text(),
-  icon_color: text(),
-  ...Timestamps,
-  time_initialized: integer(),
-  sandboxes: text({ mode: "json" }).notNull().$type<string[]>(),
-  commands: text({ mode: "json" }).$type<{ start?: string }>(),
-})

package/src/project/project.ts

@@ -1,522 +0,0 @@
-import z from "zod"
-import * as nodeFs from "fs/promises"
-import * as nodeOs from "os"
-import * as nodePath from "path"
-import { and, Database, eq } from "../storage"
-import { ProjectTable } from "./project.sql"
-import { SessionTable } from "../session/session.sql"
-import { Log } from "../util"
-import { Flag } from "@/flag/flag"
-import { BusEvent } from "@/bus/bus-event"
-import { GlobalBus } from "@/bus/global"
-import { which } from "../util/which"
-import { ProjectID } from "./schema"
-import { resolveMainGitDir, resolveProjectId } from "./project-id"
-import { Effect, Layer, Path, Scope, Context, Stream, Types, Schema } from "effect"
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
-import { NodePath } from "@effect/platform-node"
-import { AppFileSystem } from "@sleepy-ai/shared/filesystem"
-import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-async function setupProjectIdEnvironment(workingDir: string): Promise<void> {
-  const mainGit = resolveMainGitDir(workingDir)
-  if (!mainGit) return
-
-  const localFile = nodePath.join(workingDir, ".sleepycode-project-id")
-  const idFile = nodePath.join(mainGit, "sleepycode-project-id")
-
-  // 运行时无关:用 node fs(node engine 构建里没有 Bun 全局)
-  const exists = (p: string) =>
-    nodeFs
-      .access(p)
-      .then(() => true)
-      .catch(() => false)
-
-  if (await exists(localFile)) {
-    if (!(await exists(idFile))) {
-      const id = await nodeFs.readFile(localFile, "utf-8")
-      await nodeFs.writeFile(idFile, id)
-    }
-    await nodeFs.unlink(localFile).catch(() => {})
-  }
-
-  // Belt-and-suspenders: ensure .git/info/exclude lists .sleepycode-project-id
-  const excludeFile = nodePath.join(mainGit, "info", "exclude")
-  await nodeFs.mkdir(nodePath.dirname(excludeFile), { recursive: true })
-  const existing = await nodeFs.readFile(excludeFile, "utf-8").catch(() => "")
-  if (!existing.includes(".sleepycode-project-id")) {
-    await nodeFs.appendFile(excludeFile, "\n.sleepycode-project-id\n")
-  }
-}
-
-const log = Log.create({ service: "project" })
-
-const ProjectVcs = Schema.Literal("git")
-
-const ProjectIcon = Schema.Struct({
-  url: Schema.optional(Schema.String),
-  override: Schema.optional(Schema.String),
-  color: Schema.optional(Schema.String),
-})
-
-const ProjectCommands = Schema.Struct({
-  start: Schema.optional(
-    Schema.String.annotate({ description: "Startup script to run when creating a new workspace (worktree)" }),
-  ),
-})
-
-const ProjectTime = Schema.Struct({
-  created: Schema.Number,
-  updated: Schema.Number,
-  initialized: Schema.optional(Schema.Number),
-})
-
-export const Info = Schema.Struct({
-  id: ProjectID,
-  worktree: Schema.String,
-  vcs: Schema.optional(ProjectVcs),
-  name: Schema.optional(Schema.String),
-  icon: Schema.optional(ProjectIcon),
-  commands: Schema.optional(ProjectCommands),
-  time: ProjectTime,
-  sandboxes: Schema.Array(Schema.String),
-})
-  .annotate({ identifier: "Project" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Info = Types.DeepMutable<Schema.Schema.Type<typeof Info>>
-
-export const Event = {
-  Updated: BusEvent.define("project.updated", Info.zod),
-}
-
-type Row = typeof ProjectTable.$inferSelect
-
-export function fromRow(row: Row): Info {
-  const icon =
-    row.icon_url || row.icon_color ? { url: row.icon_url ?? undefined, color: row.icon_color ?? undefined } : undefined
-  return {
-    id: row.id,
-    worktree: row.worktree,
-    vcs: row.vcs ? Schema.decodeUnknownSync(ProjectVcs)(row.vcs) : undefined,
-    name: row.name ?? undefined,
-    icon,
-    time: {
-      created: row.time_created,
-      updated: row.time_updated,
-      initialized: row.time_initialized ?? undefined,
-    },
-    sandboxes: row.sandboxes,
-    commands: row.commands ?? undefined,
-  }
-}
-
-export const UpdateInput = z.object({
-  projectID: ProjectID.zod,
-  name: z.string().optional(),
-  icon: zod(ProjectIcon).optional(),
-  commands: zod(ProjectCommands).optional(),
-})
-export type UpdateInput = z.infer<typeof UpdateInput>
-
-// ---------------------------------------------------------------------------
-// Effect service
-// ---------------------------------------------------------------------------
-
-export interface Interface {
-  readonly fromDirectory: (directory: string) => Effect.Effect<{ project: Info; sandbox: string }>
-  readonly discover: (input: Info) => Effect.Effect<void>
-  readonly list: () => Effect.Effect<Info[]>
-  readonly get: (id: ProjectID) => Effect.Effect<Info | undefined>
-  readonly update: (input: UpdateInput) => Effect.Effect<Info>
-  readonly initGit: (input: { directory: string; project: Info }) => Effect.Effect<Info>
-  readonly setInitialized: (id: ProjectID) => Effect.Effect<void>
-  readonly sandboxes: (id: ProjectID) => Effect.Effect<string[]>
-  readonly addSandbox: (id: ProjectID, directory: string) => Effect.Effect<void>
-  readonly removeSandbox: (id: ProjectID, directory: string) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Project") {}
-
-type GitResult = { code: number; text: string; stderr: string }
-
-export const layer: Layer.Layer<
-  Service,
-  never,
-  AppFileSystem.Service | Path.Path | ChildProcessSpawner.ChildProcessSpawner
-> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-    const pathSvc = yield* Path.Path
-    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-
-    const git = Effect.fnUntraced(
-      function* (args: string[], opts?: { cwd?: string }) {
-        const handle = yield* spawner.spawn(
-          ChildProcess.make("git", args, { cwd: opts?.cwd, extendEnv: true, stdin: "ignore" }),
-        )
-        const [text, stderr] = yield* Effect.all(
-          [Stream.mkString(Stream.decodeText(handle.stdout)), Stream.mkString(Stream.decodeText(handle.stderr))],
-          { concurrency: 2 },
-        )
-        const code = yield* handle.exitCode
-        return { code, text, stderr } satisfies GitResult
-      },
-      Effect.scoped,
-      Effect.catch(() => Effect.succeed({ code: 1, text: "", stderr: "" } satisfies GitResult)),
-    )
-
-    const db = <T>(fn: (d: Parameters<typeof Database.use>[0] extends (trx: infer D) => any ? D : never) => T) =>
-      Effect.sync(() => Database.use(fn))
-
-    const emitUpdated = (data: Info) =>
-      Effect.sync(() =>
-        GlobalBus.emit("event", {
-          directory: "global",
-          project: data.id,
-          payload: { type: Event.Updated.type, properties: data },
-        }),
-      )
-
-    const fakeVcs = Schema.decodeUnknownSync(Schema.optional(ProjectVcs))(Flag.SLEEPYCODE_FAKE_VCS)
-
-    const resolveGitPath = (cwd: string, name: string) => {
-      if (!name) return cwd
-      name = name.replace(/[\r\n]+$/, "")
-      if (!name) return cwd
-      name = AppFileSystem.windowsPath(name)
-      if (pathSvc.isAbsolute(name)) return pathSvc.normalize(name)
-      return pathSvc.resolve(cwd, name)
-    }
-
-    const scope = yield* Scope.Scope
-
-    const fromDirectory = Effect.fn("Project.fromDirectory")(function* (directory: string) {
-      log.info("fromDirectory", { directory })
-
-      // Phase 1: discover git info
-      type DiscoveryResult = { id: ProjectID; worktree: string; sandbox: string; vcs: Info["vcs"] }
-
-      const data: DiscoveryResult = yield* Effect.gen(function* () {
-        if (Flag.SLEEPYCODE_DISABLE_GIT) {
-          return {
-            id: ProjectID.global,
-            worktree: directory,
-            sandbox: directory,
-            vcs: fakeVcs,
-          }
-        }
-
-        const dotgitMatches = yield* fs.up({ targets: [".git"], start: directory }).pipe(Effect.orDie)
-        const dotgit = dotgitMatches[0]
-
-        if (!dotgit) {
-          return {
-            id: ProjectID.global,
-            worktree: "/",
-            sandbox: "/",
-            vcs: fakeVcs,
-          }
-        }
-
-        // Refuse to anchor snapshots at the user's home directory or a filesystem root.
-        // Anchoring there makes git's pathspec walk cover the entire user tree on every
-        // turn, which has shipped as a bug for users opening sleepycode in $HOME.
-        const candidate = pathSvc.dirname(dotgit)
-        const home = process.env.HOME ?? process.env.USERPROFILE ?? nodeOs.homedir()
-        if (candidate === home || nodePath.parse(candidate).root === candidate) {
-          log.warn("ignoring .git at home or filesystem root, snapshots disabled", { dotgit })
-          return {
-            id: ProjectID.global,
-            worktree: directory,
-            sandbox: directory,
-            vcs: fakeVcs,
-          }
-        }
-
-        let sandbox = candidate
-        const gitBinary = yield* Effect.sync(() => which("git"))
-        let id: ProjectID | undefined
-
-        if (!gitBinary) {
-          return {
-            id: id ?? ProjectID.global,
-            worktree: sandbox,
-            sandbox,
-            vcs: fakeVcs,
-          }
-        }
-
-        const commonDir = yield* git(["rev-parse", "--git-common-dir"], { cwd: sandbox })
-        if (commonDir.code !== 0) {
-          return {
-            id: id ?? ProjectID.global,
-            worktree: sandbox,
-            sandbox,
-            vcs: fakeVcs,
-          }
-        }
-        const worktree = (() => {
-          const common = resolveGitPath(sandbox, commonDir.text.trim())
-          return common === sandbox ? sandbox : pathSvc.dirname(common)
-        })()
-
-        if (id == null) {
-          yield* Effect.promise(() => setupProjectIdEnvironment(sandbox))
-          id = resolveProjectId(sandbox)
-        }
-
-        const topLevel = yield* git(["rev-parse", "--show-toplevel"], { cwd: sandbox })
-        if (topLevel.code !== 0) {
-          return {
-            id,
-            worktree: sandbox,
-            sandbox,
-            vcs: fakeVcs,
-          }
-        }
-        sandbox = resolveGitPath(sandbox, topLevel.text.trim())
-
-        return { id, sandbox, worktree, vcs: "git" as const }
-      })
-
-      // Phase 2: upsert
-      const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, data.id)).get())
-      const existing = row
-        ? fromRow(row)
-        : {
-            id: data.id,
-            worktree: data.worktree,
-            vcs: data.vcs,
-            sandboxes: [] as string[],
-            time: { created: Date.now(), updated: Date.now() },
-          }
-
-      if (Flag.SLEEPYCODE_EXPERIMENTAL_ICON_DISCOVERY) yield* discover(existing).pipe(Effect.ignore, Effect.forkIn(scope))
-
-      const result: Info = {
-        ...existing,
-        worktree: data.worktree,
-        vcs: data.vcs,
-        time: { ...existing.time, updated: Date.now() },
-      }
-      if (data.sandbox !== result.worktree && !result.sandboxes.includes(data.sandbox))
-        result.sandboxes.push(data.sandbox)
-      result.sandboxes = yield* Effect.forEach(
-        result.sandboxes,
-        (s) =>
-          fs.exists(s).pipe(
-            Effect.orDie,
-            Effect.map((exists) => (exists ? s : undefined)),
-          ),
-        { concurrency: "unbounded" },
-      ).pipe(Effect.map((arr) => arr.filter((x): x is string => x !== undefined)))
-
-      yield* db((d) =>
-        d
-          .insert(ProjectTable)
-          .values({
-            id: result.id,
-            worktree: result.worktree,
-            vcs: result.vcs ?? null,
-            name: result.name,
-            icon_url: result.icon?.url,
-            icon_color: result.icon?.color,
-            time_created: result.time.created,
-            time_updated: result.time.updated,
-            time_initialized: result.time.initialized,
-            sandboxes: result.sandboxes,
-            commands: result.commands,
-          })
-          .onConflictDoUpdate({
-            target: ProjectTable.id,
-            set: {
-              worktree: result.worktree,
-              vcs: result.vcs ?? null,
-              name: result.name,
-              icon_url: result.icon?.url,
-              icon_color: result.icon?.color,
-              time_updated: result.time.updated,
-              time_initialized: result.time.initialized,
-              sandboxes: result.sandboxes,
-              commands: result.commands,
-            },
-          })
-          .run(),
-      )
-
-      if (data.id !== ProjectID.global) {
-        yield* db((d) =>
-          d
-            .update(SessionTable)
-            .set({ project_id: data.id })
-            .where(and(eq(SessionTable.project_id, ProjectID.global), eq(SessionTable.directory, data.worktree)))
-            .run(),
-        )
-      }
-
-      yield* emitUpdated(result)
-      return { project: result, sandbox: data.sandbox }
-    })
-
-    const discover = Effect.fn("Project.discover")(function* (input: Info) {
-      if (input.vcs !== "git") return
-      if (input.icon?.override) return
-      if (input.icon?.url) return
-
-      const matches = yield* fs
-        .glob("**/favicon.{ico,png,svg,jpg,jpeg,webp}", {
-          cwd: input.worktree,
-          absolute: true,
-          include: "file",
-        })
-        .pipe(Effect.orDie)
-      const shortest = matches.sort((a, b) => a.length - b.length)[0]
-      if (!shortest) return
-
-      const buffer = yield* fs.readFile(shortest).pipe(Effect.orDie)
-      const base64 = Buffer.from(buffer).toString("base64")
-      const mime = AppFileSystem.mimeType(shortest)
-      const url = `data:${mime};base64,${base64}`
-      yield* update({ projectID: input.id, icon: { url } })
-    })
-
-    const list = Effect.fn("Project.list")(function* () {
-      return yield* db((d) => d.select().from(ProjectTable).all().map(fromRow))
-    })
-
-    const get = Effect.fn("Project.get")(function* (id: ProjectID) {
-      const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, id)).get())
-      return row ? fromRow(row) : undefined
-    })
-
-    const update = Effect.fn("Project.update")(function* (input: UpdateInput) {
-      const result = yield* db((d) =>
-        d
-          .update(ProjectTable)
-          .set({
-            name: input.name,
-            icon_url: input.icon?.url,
-            icon_color: input.icon?.color,
-            commands: input.commands,
-            time_updated: Date.now(),
-          })
-          .where(eq(ProjectTable.id, input.projectID))
-          .returning()
-          .get(),
-      )
-      if (!result) throw new Error(`Project not found: ${input.projectID}`)
-      const data = fromRow(result)
-      yield* emitUpdated(data)
-      return data
-    })
-
-    const initGit = Effect.fn("Project.initGit")(function* (input: { directory: string; project: Info }) {
-      if (input.project.vcs === "git") return input.project
-      if (!(yield* Effect.sync(() => which("git")))) throw new Error("Git is not installed")
-      const result = yield* git(["init", "--quiet"], { cwd: input.directory })
-      if (result.code !== 0) {
-        throw new Error(result.stderr.trim() || result.text.trim() || "Failed to initialize git repository")
-      }
-      const { project } = yield* fromDirectory(input.directory)
-      return project
-    })
-
-    const setInitialized = Effect.fn("Project.setInitialized")(function* (id: ProjectID) {
-      yield* db((d) =>
-        d.update(ProjectTable).set({ time_initialized: Date.now() }).where(eq(ProjectTable.id, id)).run(),
-      )
-    })
-
-    const sandboxes = Effect.fn("Project.sandboxes")(function* (id: ProjectID) {
-      const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, id)).get())
-      if (!row) return []
-      const data = fromRow(row)
-      return yield* Effect.forEach(
-        data.sandboxes,
-        (dir) =>
-          fs.isDir(dir).pipe(
-            Effect.orDie,
-            Effect.map((ok) => (ok ? dir : undefined)),
-          ),
-        { concurrency: "unbounded" },
-      ).pipe(Effect.map((arr) => arr.filter((x): x is string => x !== undefined)))
-    })
-
-    const addSandbox = Effect.fn("Project.addSandbox")(function* (id: ProjectID, directory: string) {
-      const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, id)).get())
-      if (!row) throw new Error(`Project not found: ${id}`)
-      const sboxes = [...row.sandboxes]
-      if (!sboxes.includes(directory)) sboxes.push(directory)
-      const result = yield* db((d) =>
-        d
-          .update(ProjectTable)
-          .set({ sandboxes: sboxes, time_updated: Date.now() })
-          .where(eq(ProjectTable.id, id))
-          .returning()
-          .get(),
-      )
-      if (!result) throw new Error(`Project not found: ${id}`)
-      yield* emitUpdated(fromRow(result))
-    })
-
-    const removeSandbox = Effect.fn("Project.removeSandbox")(function* (id: ProjectID, directory: string) {
-      const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, id)).get())
-      if (!row) throw new Error(`Project not found: ${id}`)
-      const sboxes = row.sandboxes.filter((s) => s !== directory)
-      const result = yield* db((d) =>
-        d
-          .update(ProjectTable)
-          .set({ sandboxes: sboxes, time_updated: Date.now() })
-          .where(eq(ProjectTable.id, id))
-          .returning()
-          .get(),
-      )
-      if (!result) throw new Error(`Project not found: ${id}`)
-      yield* emitUpdated(fromRow(result))
-    })
-
-    return Service.of({
-      fromDirectory,
-      discover,
-      list,
-      get,
-      update,
-      initGit,
-      setInitialized,
-      sandboxes,
-      addSandbox,
-      removeSandbox,
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(CrossSpawnSpawner.defaultLayer),
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(NodePath.layer),
-)
-
-export function list() {
-  return Database.use((db) =>
-    db
-      .select()
-      .from(ProjectTable)
-      .all()
-      .map((row) => fromRow(row)),
-  )
-}
-
-export function get(id: ProjectID): Info | undefined {
-  const row = Database.use((db) => db.select().from(ProjectTable).where(eq(ProjectTable.id, id)).get())
-  if (!row) return undefined
-  return fromRow(row)
-}
-
-export function setInitialized(id: ProjectID) {
-  Database.use((db) =>
-    db.update(ProjectTable).set({ time_initialized: Date.now() }).where(eq(ProjectTable.id, id)).run(),
-  )
-}

package/src/project/schema.ts

@@ -1,15 +0,0 @@
-import { Schema } from "effect"
-import z from "zod"
-
-import { withStatics } from "@/util/schema"
-
-const projectIdSchema = Schema.String.pipe(Schema.brand("ProjectID"))
-
-export type ProjectID = typeof projectIdSchema.Type
-
-export const ProjectID = projectIdSchema.pipe(
-  withStatics((schema: typeof projectIdSchema) => ({
-    global: schema.make("global"),
-    zod: z.string().pipe(z.custom<ProjectID>()),
-  })),
-)