@neurocode-ai/core 1.18.8

package/src/observability/otlp.ts

@@ -0,0 +1,79 @@
+import { Layer } from "effect"
+import { OtlpLogger } from "effect/unstable/observability"
+import { Flag } from "../flag/flag"
+import { InstallationChannel, InstallationVersion } from "../installation/version"
+import { runID } from "./shared"
+
+const endpoint = Flag.OTEL_EXPORTER_OTLP_ENDPOINT
+
+const headers = Flag.OTEL_EXPORTER_OTLP_HEADERS
+  ? Flag.OTEL_EXPORTER_OTLP_HEADERS.split(",").reduce(
+      (acc, entry) => {
+        const [key, ...value] = entry.split("=")
+        acc[key] = value.join("=")
+        return acc
+      },
+      {} as Record<string, string>,
+    )
+  : undefined
+
+function resourceAttributes() {
+  const value = process.env.OTEL_RESOURCE_ATTRIBUTES
+  if (!value) return {}
+  try {
+    return Object.fromEntries(
+      value.split(",").map((entry) => {
+        const index = entry.indexOf("=")
+        if (index < 1) throw new Error("Invalid OTEL_RESOURCE_ATTRIBUTES entry")
+        return [decodeURIComponent(entry.slice(0, index)), decodeURIComponent(entry.slice(index + 1))]
+      }),
+    )
+  } catch {
+    return {}
+  }
+}
+
+export function resource(): { serviceName: string; serviceVersion: string; attributes: Record<string, string> } {
+  return {
+    serviceName: "neurocode",
+    serviceVersion: InstallationVersion,
+    attributes: {
+      ...resourceAttributes(),
+      "deployment.environment.name": InstallationChannel,
+      "neurocode.client": Flag.NEUROCODE_CLIENT,
+      "neurocode.run": runID,
+      "service.instance.id": runID,
+    },
+  }
+}
+
+export function loggers() {
+  if (!endpoint) return []
+  return [OtlpLogger.make({ url: `${endpoint}/v1/logs`, resource: resource(), headers })]
+}
+
+export async function tracingLayer() {
+  if (!endpoint) return Layer.empty
+  const NodeSdk = await import("@effect/opentelemetry/NodeSdk")
+  const OTLP = await import("@opentelemetry/exporter-trace-otlp-http")
+  const SdkBase = await import("@opentelemetry/sdk-trace-base")
+  const { AsyncLocalStorageContextManager } = await import("@opentelemetry/context-async-hooks")
+  const { context } = await import("@opentelemetry/api")
+
+  // The Effect Node SDK does not register a global context manager, but the AI SDK uses it to parent spans.
+  const manager = new AsyncLocalStorageContextManager()
+  manager.enable()
+  context.setGlobalContextManager(manager)
+
+  return NodeSdk.layer(() => ({
+    resource: resource(),
+    spanProcessor: new SdkBase.BatchSpanProcessor(
+      new OTLP.OTLPTraceExporter({
+        url: `${endpoint}/v1/traces`,
+        headers,
+      }),
+    ),
+  }))
+}
+
+export * as Otlp from "./otlp"

package/src/observability/shared.ts

@@ -0,0 +1 @@
+export const runID = crypto.randomUUID().slice(0, 8)

package/src/observability.ts

@@ -0,0 +1,24 @@
+export * as Observability from "./observability"
+
+import { NodeFileSystem } from "@effect/platform-node"
+import { LayerNode } from "./effect/layer-node"
+import { Effect, Layer, Logger, References } from "effect"
+import { FetchHttpClient } from "effect/unstable/http"
+import { OtlpSerialization } from "effect/unstable/observability"
+import { Logging } from "./observability/logging"
+import { Otlp } from "./observability/otlp"
+
+export const layer = Layer.unwrap(
+  Effect.gen(function* () {
+    const logs = Logger.layer([...Logging.loggers(), ...Otlp.loggers()], { mergeWithExisting: false }).pipe(
+      Layer.provide(NodeFileSystem.layer),
+      Layer.provide(OtlpSerialization.layerJson),
+      Layer.provide(FetchHttpClient.layer),
+      Layer.orDie,
+      Layer.merge(Layer.succeed(References.MinimumLogLevel, Logging.minimumLogLevel())),
+    )
+    return Layer.merge(logs, yield* Effect.promise(Otlp.tracingLayer))
+  }),
+)
+
+export const node = LayerNode.make({ name: "observability", layer, deps: [] })

package/src/patch.ts

@@ -0,0 +1,197 @@
+export * as Patch from "./patch"
+
+export type Hunk =
+  | { readonly type: "add"; readonly path: string; readonly contents: string }
+  | { readonly type: "delete"; readonly path: string }
+  | {
+      readonly type: "update"
+      readonly path: string
+      readonly movePath?: string
+      readonly chunks: ReadonlyArray<UpdateFileChunk>
+    }
+
+export interface UpdateFileChunk {
+  readonly oldLines: ReadonlyArray<string>
+  readonly newLines: ReadonlyArray<string>
+  readonly changeContext?: string
+  readonly endOfFile?: boolean
+}
+
+export interface FileUpdate {
+  readonly content: string
+  readonly bom: boolean
+}
+
+export function parse(patchText: string): ReadonlyArray<Hunk> {
+  const lines = stripHeredoc(patchText.trim()).split("\n")
+  const begin = lines.findIndex((line) => line.trim() === "*** Begin Patch")
+  const end = lines.findIndex((line) => line.trim() === "*** End Patch")
+  if (begin === -1 || end === -1 || begin >= end) throw new Error("Invalid patch format: missing Begin/End markers")
+
+  const hunks: Hunk[] = []
+  let index = begin + 1
+  while (index < end) {
+    const line = lines[index]!
+    if (line.startsWith("*** Add File:")) {
+      const path = line.slice("*** Add File:".length).trim()
+      if (!path) throw new Error("Invalid add file path")
+      const parsed = parseAdd(lines, index + 1)
+      hunks.push({ type: "add", path, contents: parsed.content })
+      index = parsed.next
+      continue
+    }
+    if (line.startsWith("*** Delete File:")) {
+      const path = line.slice("*** Delete File:".length).trim()
+      if (!path) throw new Error("Invalid delete file path")
+      hunks.push({ type: "delete", path })
+      index++
+      continue
+    }
+    if (line.startsWith("*** Update File:")) {
+      const path = line.slice("*** Update File:".length).trim()
+      if (!path) throw new Error("Invalid update file path")
+      let next = index + 1
+      let movePath: string | undefined
+      if (lines[next]?.startsWith("*** Move to:")) {
+        movePath = lines[next]!.slice("*** Move to:".length).trim()
+        if (!movePath) throw new Error("Invalid move file path")
+        next++
+      }
+      const parsed = parseUpdate(lines, next)
+      if (parsed.chunks.length === 0) throw new Error(`Invalid update hunk for ${path}: expected at least one @@ chunk`)
+      hunks.push({ type: "update", path, movePath, chunks: parsed.chunks })
+      index = parsed.next
+      continue
+    }
+    throw new Error(`Invalid patch line: ${line}`)
+  }
+  return hunks
+}
+
+export function derive(path: string, chunks: ReadonlyArray<UpdateFileChunk>, original: string): FileUpdate {
+  const source = splitBom(original)
+  const lines = source.text.split("\n")
+  if (lines.at(-1) === "") lines.pop()
+  const replacements = computeReplacements(lines, path, chunks)
+  const updated = [...lines]
+  for (const [start, remove, insert] of replacements.toReversed()) updated.splice(start, remove, ...insert)
+  if (updated.at(-1) !== "") updated.push("")
+  const next = splitBom(updated.join("\n"))
+  return { content: next.text, bom: source.bom || next.bom }
+}
+
+export function joinBom(text: string, bom: boolean) {
+  const stripped = splitBom(text).text
+  return bom ? `\uFEFF${stripped}` : stripped
+}
+
+function parseAdd(lines: ReadonlyArray<string>, start: number) {
+  const content: string[] = []
+  let index = start
+  while (index < lines.length && !lines[index]!.startsWith("***")) {
+    if (!lines[index]!.startsWith("+")) throw new Error(`Invalid add file line: ${lines[index]}`)
+    content.push(lines[index]!.slice(1))
+    index++
+  }
+  return { content: content.join("\n"), next: index }
+}
+
+function parseUpdate(lines: ReadonlyArray<string>, start: number) {
+  const chunks: UpdateFileChunk[] = []
+  let index = start
+  while (index < lines.length && !lines[index]!.startsWith("***")) {
+    if (!lines[index]!.startsWith("@@")) {
+      throw new Error(`Invalid update file line: ${lines[index]}`)
+    }
+    const changeContext = lines[index]!.slice(2).trim() || undefined
+    const oldLines: string[] = []
+    const newLines: string[] = []
+    let endOfFile = false
+    index++
+    while (index < lines.length && !lines[index]!.startsWith("@@")) {
+      const line = lines[index]!
+      if (line === "*** End of File") {
+        endOfFile = true
+        index++
+        break
+      }
+      if (line.startsWith("***")) break
+      if (line.startsWith(" ")) {
+        oldLines.push(line.slice(1))
+        newLines.push(line.slice(1))
+      } else if (line.startsWith("-")) oldLines.push(line.slice(1))
+      else if (line.startsWith("+")) newLines.push(line.slice(1))
+      else throw new Error(`Invalid update chunk line: ${line}`)
+      index++
+    }
+    chunks.push({ oldLines, newLines, changeContext, endOfFile: endOfFile || undefined })
+  }
+  return { chunks, next: index }
+}
+
+function computeReplacements(lines: ReadonlyArray<string>, path: string, chunks: ReadonlyArray<UpdateFileChunk>) {
+  const replacements: Array<readonly [start: number, remove: number, insert: ReadonlyArray<string>]> = []
+  let lineIndex = 0
+  for (const chunk of chunks) {
+    if (chunk.changeContext) {
+      const context = seek(lines, [chunk.changeContext], lineIndex)
+      if (context === -1) throw new Error(`Failed to find context '${chunk.changeContext}' in ${path}`)
+      lineIndex = context + 1
+    }
+    if (chunk.oldLines.length === 0) {
+      replacements.push([lines.length, 0, chunk.newLines])
+      continue
+    }
+    let oldLines = chunk.oldLines
+    let newLines = chunk.newLines
+    let found = seek(lines, oldLines, lineIndex, chunk.endOfFile)
+    if (found === -1 && oldLines.at(-1) === "") {
+      oldLines = oldLines.slice(0, -1)
+      if (newLines.at(-1) === "") newLines = newLines.slice(0, -1)
+      found = seek(lines, oldLines, lineIndex, chunk.endOfFile)
+    }
+    if (found === -1) throw new Error(`Failed to find expected lines in ${path}:\n${chunk.oldLines.join("\n")}`)
+    replacements.push([found, oldLines.length, newLines])
+    lineIndex = found + oldLines.length
+  }
+  return replacements.toSorted((left, right) => left[0] - right[0])
+}
+
+function seek(lines: ReadonlyArray<string>, pattern: ReadonlyArray<string>, start: number, eof = false) {
+  if (pattern.length === 0) return -1
+  for (const compare of [exact, rstrip, trim, normalized]) {
+    if (eof) {
+      const offset = lines.length - pattern.length
+      if (offset >= start && matches(lines, pattern, offset, compare)) return offset
+    }
+    for (let offset = start; offset <= lines.length - pattern.length; offset++) {
+      if (matches(lines, pattern, offset, compare)) return offset
+    }
+  }
+  return -1
+}
+
+function matches(
+  lines: ReadonlyArray<string>,
+  pattern: ReadonlyArray<string>,
+  offset: number,
+  compare: (left: string, right: string) => boolean,
+) {
+  return pattern.every((line, index) => compare(lines[offset + index]!, line))
+}
+
+const exact = (left: string, right: string) => left === right
+const rstrip = (left: string, right: string) => left.trimEnd() === right.trimEnd()
+const trim = (left: string, right: string) => left.trim() === right.trim()
+const normalized = (left: string, right: string) => normalize(left.trim()) === normalize(right.trim())
+const normalize = (value: string) =>
+  value
+    .replace(/[‘’‚‛]/g, "'")
+    .replace(/[“”„‟]/g, '"')
+    .replace(/[‐‑‒–—―]/g, "-")
+    .replace(/…/g, "...")
+    .replace(/ /g, " ")
+const splitBom = (text: string) =>
+  text.startsWith("\uFEFF") ? { bom: true, text: text.slice(1) } : { bom: false, text }
+const stripHeredoc = (input: string) =>
+  input.match(/^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/)?.[2] ?? input

package/src/permission/saved.ts

@@ -0,0 +1,79 @@
+export * as PermissionSaved from "./saved"
+
+import { eq } from "drizzle-orm"
+import { Context, Effect, Layer, Schema } from "effect"
+import { Database } from "../database/database"
+import { makeGlobalNode } from "../effect/app-node"
+import { ProjectV2 } from "../project"
+import { PermissionTable } from "./sql"
+import { PermissionSaved } from "@neurocode-ai/schema/permission-saved"
+
+export const ID = PermissionSaved.ID
+export type ID = typeof ID.Type
+
+export const Info = PermissionSaved.Info
+export type Info = typeof Info.Type
+
+export const ListInput = Schema.Struct({
+  projectID: ProjectV2.ID.pipe(Schema.optional),
+}).annotate({ identifier: "PermissionSaved.ListInput" })
+export type ListInput = typeof ListInput.Type
+
+export const AddInput = Schema.Struct({
+  projectID: ProjectV2.ID,
+  action: Schema.String,
+  resources: Schema.Array(Schema.String),
+}).annotate({ identifier: "PermissionSaved.AddInput" })
+export type AddInput = typeof AddInput.Type
+
+export interface Interface {
+  readonly list: (input?: ListInput) => Effect.Effect<ReadonlyArray<Info>>
+  readonly add: (input: AddInput) => Effect.Effect<void>
+  readonly remove: (id: ID) => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@neurocode/v2/PermissionSaved") {}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const { db } = yield* Database.Service
+
+    const list = Effect.fn("PermissionSaved.list")(function* (input?: ListInput) {
+      const rows = yield* db
+        .select()
+        .from(PermissionTable)
+        .where(input?.projectID ? eq(PermissionTable.project_id, input.projectID) : undefined)
+        .all()
+        .pipe(Effect.orDie)
+      return rows.map(
+        (row): Info => ({ id: row.id, projectID: row.project_id, action: row.action, resource: row.resource }),
+      )
+    })
+
+    const add = Effect.fn("PermissionSaved.add")(function* (input: AddInput) {
+      if (!input.resources.length) return
+      yield* db
+        .insert(PermissionTable)
+        .values(
+          input.resources.map((resource) => ({
+            id: ID.create(),
+            project_id: input.projectID,
+            action: input.action,
+            resource,
+          })),
+        )
+        .onConflictDoNothing()
+        .run()
+        .pipe(Effect.orDie)
+    })
+
+    const remove = Effect.fn("PermissionSaved.remove")(function* (id: ID) {
+      yield* db.delete(PermissionTable).where(eq(PermissionTable.id, id)).run().pipe(Effect.orDie)
+    })
+
+    return Service.of({ list, add, remove })
+  }),
+)
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [Database.node] })

package/src/permission/sql.ts

@@ -0,0 +1,20 @@
+import { sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core"
+import { Timestamps } from "../database/schema.sql"
+import { ProjectV2 } from "../project"
+import { ProjectTable } from "../project/sql"
+import type { PermissionSaved } from "./saved"
+
+export const PermissionTable = sqliteTable(
+  "permission",
+  {
+    id: text().$type<PermissionSaved.ID>().primaryKey(),
+    project_id: text()
+      .$type<ProjectV2.ID>()
+      .notNull()
+      .references(() => ProjectTable.id, { onDelete: "cascade" }),
+    action: text().notNull(),
+    resource: text().notNull(),
+    ...Timestamps,
+  },
+  (table) => [uniqueIndex("permission_project_action_resource_idx").on(table.project_id, table.action, table.resource)],
+)