@neurocode-ai/core 1.18.8

package/script/fix-node-pty.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env bun
+
+import fs from "fs/promises"
+import path from "path"
+import { fileURLToPath } from "url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const dir = path.resolve(__dirname, "..")
+
+if (process.platform !== "win32") {
+  const root = path.join(dir, "node_modules", "node-pty", "prebuilds")
+  const dirs = await fs.readdir(root, { withFileTypes: true }).catch(() => [])
+  const files = dirs.filter((x) => x.isDirectory()).map((x) => path.join(root, x.name, "spawn-helper"))
+  const result = await Promise.all(
+    files.map(async (file) => {
+      const stat = await fs.stat(file).catch(() => undefined)
+      if (!stat) return
+      if ((stat.mode & 0o111) === 0o111) return
+      await fs.chmod(file, stat.mode | 0o755)
+      return file
+    }),
+  )
+  const fixed = result.filter(Boolean)
+  if (fixed.length) {
+    console.log(`fixed node-pty permissions for ${fixed.length} helper${fixed.length === 1 ? "" : "s"}`)
+  }
+}

package/script/migration.ts

@@ -0,0 +1,196 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { pathToFileURL } from "url"
+import { parseArgs } from "util"
+
+const root = path.resolve(import.meta.dirname, "../../..")
+const snapshot = path.join(root, "packages/core/schema.json")
+const tsDir = path.join(root, "packages/core/src/database/migration")
+const registry = path.join(root, "packages/core/src/database/migration.gen.ts")
+const schema = path.join(root, "packages/core/src/database/schema.gen.ts")
+const args = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    check: { type: "boolean" },
+    name: { type: "string" },
+  },
+})
+
+if (args.values.check) {
+  await check()
+  process.exit(0)
+}
+
+await generate()
+
+async function generate() {
+  const temporary = await fs.mkdtemp(path.join(os.tmpdir(), "neurocode-core-migration-"))
+  const incremental = path.join(temporary, "incremental")
+  const full = path.join(temporary, "full")
+  try {
+    await fs.mkdir(incremental)
+    await fs.mkdir(path.join(incremental, "baseline"))
+    await fs.copyFile(snapshot, path.join(incremental, "baseline/snapshot.json"))
+    await drizzle(temporary, incremental, args.values.name)
+
+    const generated = await generatedMigrations(incremental)
+    if (generated.length > 1) throw new Error(`Expected one generated migration, found ${generated.length}.`)
+    const name = generated[0]
+    if (name) {
+      const target = path.join(tsDir, `${name}.ts`)
+      if (await Bun.file(target).exists()) throw new Error(`Database migration already exists: ${name}`)
+      await Bun.write(
+        target,
+        await formatTypescript(
+          renderMigration(name, await Bun.file(path.join(incremental, name, "migration.sql")).text()),
+        ),
+      )
+      await fs.copyFile(path.join(incremental, name, "snapshot.json"), snapshot)
+    }
+
+    await fs.mkdir(full)
+    await drizzle(temporary, full, "schema")
+    await Bun.write(schema, await formatTypescript(renderSchema(await generatedSql(full))))
+    await Bun.write(registry, await formatTypescript(renderRegistry(await typescriptMigrations())))
+  } finally {
+    await fs.rm(temporary, { recursive: true, force: true })
+  }
+}
+
+async function check() {
+  const temporary = await fs.mkdtemp(path.join(os.tmpdir(), "neurocode-core-migration-check-"))
+  const incremental = path.join(temporary, "incremental")
+  const full = path.join(temporary, "full")
+  try {
+    await fs.mkdir(incremental)
+    await fs.mkdir(path.join(incremental, "baseline"))
+    await fs.copyFile(snapshot, path.join(incremental, "baseline/snapshot.json"))
+    await drizzle(temporary, incremental)
+    if ((await generatedMigrations(incremental)).length > 0) {
+      throw new Error(
+        "Core schema has ungenerated database migrations. Run `bun script/migration.ts` from packages/core.",
+      )
+    }
+
+    await fs.mkdir(full)
+    await drizzle(temporary, full, "schema")
+    if ((await Bun.file(schema).text()) !== (await formatTypescript(renderSchema(await generatedSql(full))))) {
+      throw new Error("Current database schema is stale. Run `bun script/migration.ts` from packages/core.")
+    }
+
+    const migrations = await typescriptMigrations()
+    if ((await Bun.file(registry).text()) !== (await formatTypescript(renderRegistry(migrations)))) {
+      throw new Error("Database migration registry is stale. Run `bun script/migration.ts` from packages/core.")
+    }
+  } finally {
+    await fs.rm(temporary, { recursive: true, force: true })
+  }
+}
+
+async function drizzle(temporary: string, output: string, name?: string) {
+  const config = path.join(temporary, `${path.basename(output)}.config.ts`)
+  await Bun.write(
+    config,
+    `import config from ${JSON.stringify(pathToFileURL(path.join(root, "packages/core/drizzle.config.ts")).href)}
+
+export default { ...config, out: ${JSON.stringify(output)} }
+`,
+  )
+  await $`bun drizzle-kit generate --config ${config} ${name ? ["--name", name] : []}`.cwd(
+    path.join(root, "packages/core"),
+  )
+}
+
+async function generatedMigrations(directory: string) {
+  return (await Array.fromAsync(new Bun.Glob("*/migration.sql").scan({ cwd: directory })))
+    .map((file) => file.split("/")[0])
+    .filter((name): name is string => name !== undefined)
+    .sort()
+}
+
+async function generatedSql(directory: string) {
+  const generated = await generatedMigrations(directory)
+  if (generated.length !== 1) throw new Error(`Expected one full schema migration, found ${generated.length}.`)
+  return Bun.file(path.join(directory, generated[0]!, "migration.sql")).text()
+}
+
+async function typescriptMigrations() {
+  return (await Array.fromAsync(new Bun.Glob("*.ts").scan({ cwd: tsDir })))
+    .map((file) => path.basename(file, ".ts"))
+    .sort()
+}
+
+function renderMigration(name: string, sql: string) {
+  return `import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+export default {
+  id: ${JSON.stringify(name)},
+  up(tx) {
+    return Effect.gen(function* () {
+${renderStatements(sql)}
+    })
+  },
+} satisfies DatabaseMigration.Migration
+`
+}
+
+function renderSchema(sql: string) {
+  return `import { Effect } from "effect"
+import type { DatabaseMigration } from "./migration"
+
+export default {
+  up(tx) {
+    return Effect.gen(function* () {
+${renderStatements(sql)}
+    })
+  },
+} satisfies Omit<DatabaseMigration.Migration, "id">
+`
+}
+
+function renderStatements(sql: string) {
+  return sql
+    .split("--> statement-breakpoint")
+    .map((statement) => statement.trim())
+    .filter((statement) => statement.length > 0)
+    .map(renderRun)
+    .join("\n")
+}
+
+function renderRun(statement: string) {
+  const lines = statement.replaceAll("\t", "  ").split("\n")
+  if (lines.length === 1) return `      yield* tx.run(\`${escapeTemplate(lines[0])}\`)`
+  return `      yield* tx.run(\`\n${lines.map((line) => `        ${escapeTemplate(line)}`).join("\n")}\n      \`)`
+}
+
+function escapeTemplate(line: string) {
+  return line.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("${", "\\${")
+}
+
+async function formatTypescript(input: string) {
+  const prettier = await import("prettier")
+  const typescript = await import("prettier/plugins/typescript")
+  const estree = await import("prettier/plugins/estree")
+  return prettier.format(input, {
+    parser: "typescript",
+    plugins: [typescript.default, estree.default],
+    semi: false,
+    printWidth: 120,
+  })
+}
+
+function renderRegistry(names: string[]) {
+  return `import type { DatabaseMigration } from "./migration"
+
+export const migrations = (
+  await Promise.all([
+${names.map((name) => `    import("./migration/${name}"),`).join("\n")}
+  ])
+).map((module) => module.default) satisfies DatabaseMigration.Migration[]
+`
+}

package/src/account/sql.ts

@@ -0,0 +1,39 @@
+import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core"
+
+import { AccountV2 } from "../account"
+import { Timestamps } from "../database/schema.sql"
+
+export const AccountTable = sqliteTable("account", {
+  id: text().$type<AccountV2.ID>().primaryKey(),
+  email: text().notNull(),
+  url: text().notNull(),
+  access_token: text().$type<AccountV2.AccessToken>().notNull(),
+  refresh_token: text().$type<AccountV2.RefreshToken>().notNull(),
+  token_expiry: integer(),
+  ...Timestamps,
+})
+
+export const AccountStateTable = sqliteTable("account_state", {
+  id: integer().primaryKey(),
+  active_account_id: text()
+    .$type<AccountV2.ID>()
+    .references(() => AccountTable.id, { onDelete: "set null" }),
+  active_org_id: text().$type<AccountV2.OrgID>(),
+})
+
+// LEGACY
+export const ControlAccountTable = sqliteTable(
+  "control_account",
+  {
+    email: text().notNull(),
+    url: text().notNull(),
+    access_token: text().$type<AccountV2.AccessToken>().notNull(),
+    refresh_token: text().$type<AccountV2.RefreshToken>().notNull(),
+    token_expiry: integer(),
+    active: integer({ mode: "boolean" })
+      .notNull()
+      .$default(() => false),
+    ...Timestamps,
+  },
+  (table) => [primaryKey({ columns: [table.email, table.url] })],
+)

package/src/account.ts

@@ -0,0 +1,101 @@
+export * as AccountV2 from "./account"
+
+import { Schema } from "effect"
+import type * as HttpClientError from "effect/unstable/http/HttpClientError"
+
+export const ID = Schema.String.pipe(Schema.brand("AccountID"))
+export type ID = Schema.Schema.Type<typeof ID>
+
+export const OrgID = Schema.String.pipe(Schema.brand("OrgID"))
+export type OrgID = Schema.Schema.Type<typeof OrgID>
+
+export const AccessToken = Schema.String.pipe(Schema.brand("AccessToken"))
+export type AccessToken = Schema.Schema.Type<typeof AccessToken>
+
+export const RefreshToken = Schema.String.pipe(Schema.brand("RefreshToken"))
+export type RefreshToken = Schema.Schema.Type<typeof RefreshToken>
+
+export const DeviceCode = Schema.String.pipe(Schema.brand("DeviceCode"))
+export type DeviceCode = Schema.Schema.Type<typeof DeviceCode>
+
+export const UserCode = Schema.String.pipe(Schema.brand("UserCode"))
+export type UserCode = Schema.Schema.Type<typeof UserCode>
+
+export class Info extends Schema.Class<Info>("Account")({
+  id: ID,
+  email: Schema.String,
+  url: Schema.String,
+  active_org_id: Schema.NullOr(OrgID),
+}) {}
+
+export class Org extends Schema.Class<Org>("Org")({
+  id: OrgID,
+  name: Schema.String,
+}) {}
+
+export class AccountRepoError extends Schema.TaggedErrorClass<AccountRepoError>()("AccountRepoError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect()),
+}) {}
+
+export class AccountServiceError extends Schema.TaggedErrorClass<AccountServiceError>()("AccountServiceError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect()),
+}) {}
+
+export class AccountTransportError extends Schema.TaggedErrorClass<AccountTransportError>()("AccountTransportError", {
+  method: Schema.String,
+  url: Schema.String,
+  description: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Defect()),
+}) {
+  static fromHttpClientError(error: HttpClientError.TransportError): AccountTransportError {
+    return new AccountTransportError({
+      method: error.request.method,
+      url: error.request.url,
+      description: error.description,
+      cause: error.cause,
+    })
+  }
+
+  override get message(): string {
+    return [
+      `Could not reach ${this.method} ${this.url}.`,
+      `This failed before the server returned an HTTP response.`,
+      this.description,
+      `Check your network, proxy, or VPN configuration and try again.`,
+    ]
+      .filter(Boolean)
+      .join("\n")
+  }
+}
+
+export type AccountError = AccountRepoError | AccountServiceError | AccountTransportError
+
+export class Login extends Schema.Class<Login>("Login")({
+  code: DeviceCode,
+  user: UserCode,
+  url: Schema.String,
+  server: Schema.String,
+  expiry: Schema.Duration,
+  interval: Schema.Duration,
+}) {}
+
+export class PollSuccess extends Schema.TaggedClass<PollSuccess>()("PollSuccess", {
+  email: Schema.String,
+}) {}
+
+export class PollPending extends Schema.TaggedClass<PollPending>()("PollPending", {}) {}
+
+export class PollSlow extends Schema.TaggedClass<PollSlow>()("PollSlow", {}) {}
+
+export class PollExpired extends Schema.TaggedClass<PollExpired>()("PollExpired", {}) {}
+
+export class PollDenied extends Schema.TaggedClass<PollDenied>()("PollDenied", {}) {}
+
+export class PollError extends Schema.TaggedClass<PollError>()("PollError", {
+  cause: Schema.Defect(),
+}) {}
+
+export const PollResult = Schema.Union([PollSuccess, PollPending, PollSlow, PollExpired, PollDenied, PollError])
+export type PollResult = Schema.Schema.Type<typeof PollResult>

package/src/agent.ts

@@ -0,0 +1,111 @@
+export * as AgentV2 from "./agent"
+
+import { makeLocationNode } from "./effect/app-node"
+import { Array, Context, Effect, Layer, Types } from "effect"
+import { Agent } from "@neurocode-ai/schema/agent"
+import { State } from "./state"
+
+export const ID = Agent.ID
+export type ID = typeof ID.Type
+export const defaultID = ID.make("neuro")
+
+export const Color = Agent.Color
+
+export const Info = Agent.Info
+export type Info = Agent.Info
+
+export interface Selection {
+  readonly id: ID
+  readonly info: Info | undefined
+}
+
+type Data = {
+  agents: Map<ID, Types.DeepMutable<Info>>
+  default?: ID
+}
+
+export type Draft = {
+  list: () => readonly Info[]
+  get: (id: ID) => Info | undefined
+  default: (id: ID | undefined) => void
+  update: (id: ID, fn: (agent: Types.DeepMutable<Info>) => void) => void
+  remove: (id: ID) => void
+}
+
+export interface Interface extends State.Transformable<Draft> {
+  readonly get: (id: ID) => Effect.Effect<Info | undefined>
+  readonly default: () => Effect.Effect<Info | undefined>
+  readonly resolve: (id?: ID | string) => Effect.Effect<Info | undefined>
+  readonly select: (id?: ID | string) => Effect.Effect<Selection>
+  readonly all: () => Effect.Effect<Info[]>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@neurocode/v2/Agent") {}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const state = State.create<Data, Draft>({
+      initial: () => ({ agents: new Map() }),
+      draft: (draft) => ({
+        list: () => Array.fromIterable(draft.agents.values()) as Info[],
+        get: (id) => draft.agents.get(id),
+        default: (id) => {
+          draft.default = id
+        },
+        update: (id, fn) => {
+          const current = draft.agents.get(id) ?? (Info.empty(id) as Types.DeepMutable<Info>)
+          if (!draft.agents.has(id)) draft.agents.set(id, current)
+          fn(current)
+          current.id = id
+        },
+        remove: (id) => {
+          draft.agents.delete(id)
+        },
+      }),
+    })
+    const selectable = (agent: Info | undefined) =>
+      agent && agent.mode !== "subagent" && !agent.hidden ? agent : undefined
+    const selectedDefault = () => {
+      const data = state.get()
+      const configured = data.default ? selectable(data.agents.get(data.default)) : undefined
+      if (configured) return configured
+      const neuro = selectable(data.agents.get(ID.make("neuro")))
+      if (neuro) return neuro
+      for (const agent of data.agents.values()) {
+        const fallback = selectable(agent)
+        if (fallback) return fallback
+      }
+    }
+
+    return Service.of({
+      transform: state.transform,
+      reload: state.reload,
+      get: Effect.fn("AgentV2.get")(function* (id) {
+        return state.get().agents.get(id)
+      }),
+      default: Effect.fn("AgentV2.default")(function* () {
+        return selectedDefault()
+      }),
+      resolve: Effect.fn("AgentV2.resolve")(function* (id) {
+        if (id !== undefined) return state.get().agents.get(ID.make(id))
+        return selectedDefault()
+      }),
+      select: Effect.fn("AgentV2.select")(function* (id) {
+        if (id !== undefined) {
+          const selected = ID.make(id)
+          return { id: selected, info: state.get().agents.get(selected) }
+        }
+        const info = selectedDefault()
+        return { id: info?.id ?? defaultID, info }
+      }),
+      all: Effect.fn("AgentV2.all")(function* () {
+        return Array.fromIterable(state.get().agents.values())
+      }),
+    })
+  }),
+)
+
+export const locationLayer = layer
+
+export const node = makeLocationNode({ service: Service, layer, deps: [] })