openAgent

1export * as ProjectV2 from "./project"
2export * as Project from "./project"
3 
4import { Context, Effect, Layer, Schema } from "effect"
5import path from "path"
6import { AbsolutePath } from "./schema"
7import { FSUtil } from "./fs-util"
8import { Git } from "./git"
9import { makeGlobalNode } from "./effect/app-node"
10import { Hash } from "./util/hash"
11import { ProjectDirectories } from "./project/directories"
12import { ProjectSchema } from "./project/schema"
13 
14export const ID = ProjectSchema.ID
15export type ID = ProjectSchema.ID
16 
17export const Vcs = ProjectSchema.Vcs
18export type Vcs = ProjectSchema.Vcs
19 
20export class Info extends Schema.Class<Info>("Project.Info")({
21  id: ID,
22}) {}
23 
24export const DirectoriesInput = ProjectDirectories.ListInput
25export type DirectoriesInput = typeof DirectoriesInput.Type
26 
27export const Directories = ProjectDirectories.ListOutput
28export type Directories = typeof Directories.Type
29 
30export interface Resolved {
31  readonly previous?: ID
32  readonly id: ID
33  readonly directory: AbsolutePath
34  readonly vcs?: Vcs
35}
36 
37export interface Interface {
38  readonly directories: (input: DirectoriesInput) => Effect.Effect<Directories>
39  readonly resolve: (input: AbsolutePath) => Effect.Effect<Resolved>
40  /**
41   * Temporary bridge method for writing the resolved project ID to the repo-local cache.
42   *
43   * This exists while the old opencode project service and this core project
44   * service work together: core resolves the ID, while the old service still owns
45   * database migration and persistence. The old service should call this after it
46   * finishes migrating from `resolve().previous` to `resolve().id`; once project
47   * persistence moves into core, this separate bridge method can go away.
48   */
49  readonly commit: (input: { store: AbsolutePath; id: ID }) => Effect.Effect<void>
50}
51 
52export class Service extends Context.Service<Service, Interface>()("@opencode/ProjectV2") {}
53 
54const layer = Layer.effect(
55  Service,
56  Effect.gen(function* () {
57    const fs = yield* FSUtil.Service
58    const git = yield* Git.Service
59    const projectDirectories = yield* ProjectDirectories.Service
60 
61    const directories = Effect.fn("Project.directories")(function* (input: DirectoriesInput) {
62      return yield* projectDirectories.list(input.projectID)
63    })
64 
65    const cached = Effect.fnUntraced(function* (dir: string) {
66      return yield* fs.readFileString(path.join(dir, "opencode")).pipe(
67        Effect.map((value) => value.trim()),
68        Effect.map((value) => (value ? ID.make(value) : undefined)),
69        Effect.catch(() => Effect.succeed(undefined)),
70      )
71    })
72 
73    const remote = Effect.fnUntraced(function* (repo: Git.Repository) {
74      const origin = yield* git.remote.get(repo)
75      if (!origin) return undefined
76      const normalized = url(origin)
77      if (!normalized) return undefined
78      return ID.make(Hash.fast(`git-remote:${normalized}`))
79    })
80 
81    function url(input: string) {
82      const value = input.trim()
83      if (!value) return undefined
84 
85      try {
86        const parsed = new URL(value)
87        if (parsed.protocol === "file:") return undefined
88        return parts(parsed.hostname, parsed.pathname)
89      } catch {
90        const scp = value.match(/^([^@/:]+@)?([^/:]+):(.+)$/)
91        if (scp) return parts(scp[2], scp[3])
92        return undefined
93      }
94    }
95 
96    function parts(host: string, name: string) {
97      const pathname = name
98        .replace(/^\/+/, "")
99        .replace(/\.git\/?$/, "")
100        .replace(/\/+$/, "")
101      if (!host || !pathname) return undefined
102      return `${host.toLowerCase()}/${pathname}`
103    }
104 
105    const root = Effect.fnUntraced(function* (repo: Git.Repository) {
106      const root = (yield* git.history.rootCommits(repo))[0]
107      return root ? ID.make(root) : undefined
108    })
109 
110    const resolve = Effect.fn("Project.resolve")(function* (input: AbsolutePath) {
111      const repo = yield* git.repo.discover(input)
112      if (!repo) return { id: ID.global, directory: AbsolutePath.make(path.parse(input).root), vcs: undefined }
113 
114      const previous = yield* cached(repo.commonDirectory)
115      const id = (yield* remote(repo)) ?? previous ?? (yield* root(repo))
116      return {
117        previous,
118        id: id ?? ID.global,
119        directory: repo.worktree,
120        vcs: { type: "git" as const, store: repo.commonDirectory },
121      }
122    })
123 
124    const commit = Effect.fn("Project.commit")(function* (input: { store: AbsolutePath; id: ID }) {
125      yield* fs.writeFileString(path.join(input.store, "opencode"), input.id).pipe(Effect.ignore)
126    })
127 
128    return Service.of({ directories, resolve, commit })
129  }),
130)
131 
132export const node = makeGlobalNode({
133  service: Service,
134  layer: layer,
135  deps: [FSUtil.node, Git.node, ProjectDirectories.node],
136})
137