@vikasitai/vikasit-code 2.0.7 → 2.0.9

package/src/sync/index.ts

@@ -1,263 +0,0 @@
-import z from "zod"
-import type { ZodObject } from "zod"
-import { EventEmitter } from "events"
-import { Database, eq } from "@/storage/db"
-import { Bus as ProjectBus } from "@/bus"
-import { BusEvent } from "@/bus/bus-event"
-import { EventSequenceTable, EventTable } from "./event.sql"
-import { EventID } from "./schema"
-import { Flag } from "@/flag/flag"
-
-export namespace SyncEvent {
-  export type Definition = {
-    type: string
-    version: number
-    aggregate: string
-    schema: z.ZodObject
-
-    // This is temporary and only exists for compatibility with bus
-    // event definitions
-    properties: z.ZodObject
-  }
-
-  export type Event<Def extends Definition = Definition> = {
-    id: string
-    seq: number
-    aggregateID: string
-    data: z.infer<Def["schema"]>
-  }
-
-  export type SerializedEvent<Def extends Definition = Definition> = Event<Def> & { type: string }
-
-  type ProjectorFunc = (db: Database.TxOrDb, data: unknown) => void
-
-  export const registry = new Map<string, Definition>()
-  let projectors: Map<Definition, ProjectorFunc> | undefined
-  const versions = new Map<string, number>()
-  let frozen = false
-  let convertEvent: (type: string, event: Event["data"]) => Promise<Record<string, unknown>> | Record<string, unknown>
-
-  const Bus = new EventEmitter<{ event: [{ def: Definition; event: Event }] }>()
-
-  export function reset() {
-    frozen = false
-    projectors = undefined
-    convertEvent = (_, data) => data
-  }
-
-  export function init(input: { projectors: Array<[Definition, ProjectorFunc]>; convertEvent?: typeof convertEvent }) {
-    projectors = new Map(input.projectors)
-
-    // Install all the latest event defs to the bus. We only ever emit
-    // latest versions from code, and keep around old versions for
-    // replaying. Replaying does not go through the bus, and it
-    // simplifies the bus to only use unversioned latest events
-    for (let [type, version] of versions.entries()) {
-      let def = registry.get(versionedType(type, version))!
-
-      BusEvent.define(def.type, def.properties || def.schema)
-    }
-
-    // Freeze the system so it clearly errors if events are defined
-    // after `init` which would cause bugs
-    frozen = true
-    convertEvent = input.convertEvent || ((_, data) => data)
-  }
-
-  export function versionedType<A extends string>(type: A): A
-  export function versionedType<A extends string, B extends number>(type: A, version: B): `${A}/${B}`
-  export function versionedType(type: string, version?: number) {
-    return version ? `${type}.${version}` : type
-  }
-
-  export function define<
-    Type extends string,
-    Agg extends string,
-    Schema extends ZodObject<Record<Agg, z.ZodType<string>>>,
-    BusSchema extends ZodObject = Schema,
-  >(input: { type: Type; version: number; aggregate: Agg; schema: Schema; busSchema?: BusSchema }) {
-    if (frozen) {
-      throw new Error("Error defining sync event: sync system has been frozen")
-    }
-
-    const def = {
-      type: input.type,
-      version: input.version,
-      aggregate: input.aggregate,
-      schema: input.schema,
-      properties: input.busSchema ? input.busSchema : input.schema,
-    }
-
-    versions.set(def.type, Math.max(def.version, versions.get(def.type) || 0))
-
-    registry.set(versionedType(def.type, def.version), def)
-
-    return def
-  }
-
-  export function project<Def extends Definition>(
-    def: Def,
-    func: (db: Database.TxOrDb, data: Event<Def>["data"]) => void,
-  ): [Definition, ProjectorFunc] {
-    return [def, func as ProjectorFunc]
-  }
-
-  function process<Def extends Definition>(def: Def, event: Event<Def>, options: { publish: boolean }) {
-    if (projectors == null) {
-      throw new Error("No projectors available. Call `SyncEvent.init` to install projectors")
-    }
-
-    const projector = projectors.get(def)
-    if (!projector) {
-      throw new Error(`Projector not found for event: ${def.type}`)
-    }
-
-    // idempotent: need to ignore any events already logged
-
-    Database.transaction((tx) => {
-      projector(tx, event.data)
-
-      if (Flag.VIKASIT_EXPERIMENTAL_WORKSPACES) {
-        tx.insert(EventSequenceTable)
-          .values({
-            aggregate_id: event.aggregateID,
-            seq: event.seq,
-          })
-          .onConflictDoUpdate({
-            target: EventSequenceTable.aggregate_id,
-            set: { seq: event.seq },
-          })
-          .run()
-        tx.insert(EventTable)
-          .values({
-            id: event.id,
-            seq: event.seq,
-            aggregate_id: event.aggregateID,
-            type: versionedType(def.type, def.version),
-            data: event.data as Record<string, unknown>,
-          })
-          .run()
-      }
-
-      Database.effect(() => {
-        Bus.emit("event", {
-          def,
-          event,
-        })
-
-        if (options?.publish) {
-          const result = convertEvent(def.type, event.data)
-          if (result instanceof Promise) {
-            result.then((data) => {
-              ProjectBus.publish({ type: def.type, properties: def.schema }, data)
-            })
-          } else {
-            ProjectBus.publish({ type: def.type, properties: def.schema }, result)
-          }
-        }
-      })
-    })
-  }
-
-  // TODO:
-  //
-  // * Support applying multiple events at one time. One transaction,
-  //   and it validets all the sequence ids
-  // * when loading events from db, apply zod validation to ensure shape
-
-  export function replay(event: SerializedEvent, options?: { republish: boolean }) {
-    const def = registry.get(event.type)
-    if (!def) {
-      throw new Error(`Unknown event type: ${event.type}`)
-    }
-
-    const row = Database.use((db) =>
-      db
-        .select({ seq: EventSequenceTable.seq })
-        .from(EventSequenceTable)
-        .where(eq(EventSequenceTable.aggregate_id, event.aggregateID))
-        .get(),
-    )
-
-    const latest = row?.seq ?? -1
-    if (event.seq <= latest) {
-      return
-    }
-
-    const expected = latest + 1
-    if (event.seq !== expected) {
-      throw new Error(`Sequence mismatch for aggregate "${event.aggregateID}": expected ${expected}, got ${event.seq}`)
-    }
-
-    process(def, event, { publish: !!options?.republish })
-  }
-
-  export function run<Def extends Definition>(def: Def, data: Event<Def>["data"]) {
-    const agg = (data as Record<string, string>)[def.aggregate]
-    // This should never happen: we've enforced it via typescript in
-    // the definition
-    if (agg == null) {
-      throw new Error(`SyncEvent.run: "${def.aggregate}" required but not found: ${JSON.stringify(data)}`)
-    }
-
-    if (def.version !== versions.get(def.type)) {
-      throw new Error(`SyncEvent.run: running old versions of events is not allowed: ${def.type}`)
-    }
-
-    // Note that this is an "immediate" transaction which is critical.
-    // We need to make sure we can safely read and write with nothing
-    // else changing the data from under us
-    Database.transaction(
-      (tx) => {
-        const id = EventID.ascending()
-        const row = tx
-          .select({ seq: EventSequenceTable.seq })
-          .from(EventSequenceTable)
-          .where(eq(EventSequenceTable.aggregate_id, agg))
-          .get()
-        const seq = row?.seq != null ? row.seq + 1 : 0
-
-        const event = { id, seq, aggregateID: agg, data }
-        process(def, event, { publish: true })
-      },
-      {
-        behavior: "immediate",
-      },
-    )
-  }
-
-  export function remove(aggregateID: string) {
-    Database.transaction((tx) => {
-      tx.delete(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run()
-      tx.delete(EventTable).where(eq(EventTable.aggregate_id, aggregateID)).run()
-    })
-  }
-
-  export function subscribeAll(handler: (event: { def: Definition; event: Event }) => void) {
-    Bus.on("event", handler)
-    return () => Bus.off("event", handler)
-  }
-
-  export function payloads() {
-    return z
-      .union(
-        registry
-          .entries()
-          .map(([type, def]) => {
-            return z
-              .object({
-                type: z.literal(type),
-                aggregate: z.literal(def.aggregate),
-                data: def.schema,
-              })
-              .meta({
-                ref: "SyncEvent" + "." + def.type,
-              })
-          })
-          .toArray() as any,
-      )
-      .meta({
-        ref: "SyncEvent",
-      })
-  }
-}

package/src/sync/schema.ts

@@ -1,14 +0,0 @@
-import { Schema } from "effect"
-import z from "zod"
-
-import { Identifier } from "@/id/id"
-import { withStatics } from "@/util/schema"
-
-export const EventID = Schema.String.pipe(
-  Schema.brand("EventID"),
-  withStatics((s) => ({
-    make: (id: string) => s.makeUnsafe(id),
-    ascending: (id?: string) => s.makeUnsafe(Identifier.ascending("event", id)),
-    zod: Identifier.schema("event").pipe(z.custom<Schema.Schema.Type<typeof s>>()),
-  })),
-)

package/src/task/index.ts

@@ -1,89 +0,0 @@
-import { Log } from "@/util/log"
-import type { TaskInfo, TaskStatus } from "./schema"
-
-export namespace Task {
-  const log = Log.create({ service: "task" })
-
-  // In-memory store (sessions are ephemeral)
-  const tasks = new Map<string, TaskInfo>()
-  let nextId = 1
-
-  export function create(input: {
-    sessionID: string
-    description: string
-    agentType: string
-    parentTaskID?: string
-    blocks?: string[]
-    blockedBy?: string[]
-  }): TaskInfo {
-    const id = `task_${nextId++}`
-    const task: TaskInfo = {
-      id,
-      sessionID: input.sessionID,
-      parentTaskID: input.parentTaskID,
-      description: input.description,
-      status: "pending",
-      agentType: input.agentType,
-      blocks: input.blocks,
-      blockedBy: input.blockedBy,
-      time: { created: Date.now() },
-    }
-    tasks.set(id, task)
-    log.info("created", { taskId: id, description: input.description })
-    return task
-  }
-
-  export function get(taskId: string): TaskInfo | undefined {
-    return tasks.get(taskId)
-  }
-
-  export function list(sessionID?: string): TaskInfo[] {
-    const all = Array.from(tasks.values())
-    if (sessionID) return all.filter((t) => t.sessionID === sessionID)
-    return all
-  }
-
-  export function update(
-    taskId: string,
-    updates: Partial<
-      Pick<TaskInfo, "status" | "result" | "error" | "childSessionID" | "blocks" | "blockedBy">
-    >,
-  ): TaskInfo | undefined {
-    const task = tasks.get(taskId)
-    if (!task) return undefined
-
-    if (updates.status) {
-      task.status = updates.status
-      if (updates.status === "in_progress" && !task.time.started) {
-        task.time.started = Date.now()
-      }
-      if (updates.status === "completed" || updates.status === "failed" || updates.status === "killed") {
-        task.time.completed = Date.now()
-      }
-    }
-    if (updates.result !== undefined) task.result = updates.result
-    if (updates.error !== undefined) task.error = updates.error
-    if (updates.childSessionID !== undefined) task.childSessionID = updates.childSessionID
-    if (updates.blocks) task.blocks = [...(task.blocks ?? []), ...updates.blocks]
-    if (updates.blockedBy) task.blockedBy = [...(task.blockedBy ?? []), ...updates.blockedBy]
-
-    log.info("updated", { taskId, status: task.status })
-    return task
-  }
-
-  export function remove(taskId: string): boolean {
-    const removed = tasks.delete(taskId)
-    if (removed) log.info("removed", { taskId })
-    return removed
-  }
-
-  export function stop(taskId: string): TaskInfo | undefined {
-    return update(taskId, { status: "killed" })
-  }
-
-  export function reset() {
-    tasks.clear()
-    nextId = 1
-    log.info("reset")
-  }
-}

package/src/task/schema.ts

@@ -1,39 +0,0 @@
-import { Schema } from "effect"
-import z from "zod"
-
-import { Identifier } from "@/id/id"
-import { withStatics } from "@/util/schema"
-
-export const TaskID = Schema.String.pipe(
-  Schema.brand("TaskID"),
-  withStatics((s) => ({
-    make: (id: string) => s.makeUnsafe(id),
-    ascending: (id?: string) => s.makeUnsafe(Identifier.ascending("tool", id)),
-    zod: Identifier.schema("tool").pipe(z.custom<Schema.Schema.Type<typeof s>>()),
-  })),
-)
-
-export type TaskID = Schema.Schema.Type<typeof TaskID>
-
-export const TaskStatus = z.enum(["pending", "in_progress", "completed", "failed", "killed"])
-export type TaskStatus = z.infer<typeof TaskStatus>
-
-export const TaskInfo = z.object({
-  id: z.string(),
-  sessionID: z.string(),
-  parentTaskID: z.string().optional(),
-  description: z.string(),
-  status: TaskStatus,
-  agentType: z.string(),
-  childSessionID: z.string().optional(),
-  blocks: z.array(z.string()).optional(),
-  blockedBy: z.array(z.string()).optional(),
-  result: z.string().optional(),
-  error: z.string().optional(),
-  time: z.object({
-    created: z.number(),
-    started: z.number().optional(),
-    completed: z.number().optional(),
-  }),
-})
-export type TaskInfo = z.infer<typeof TaskInfo>

package/src/tool/apply_patch.ts

@@ -1,281 +0,0 @@
-import z from "zod"
-import * as path from "path"
-import * as fs from "fs/promises"
-import { Tool } from "./tool"
-import { Bus } from "../bus"
-import { FileWatcher } from "../file/watcher"
-import { Instance } from "../project/instance"
-import { Patch } from "../patch"
-import { createTwoFilesPatch, diffLines } from "diff"
-import { assertExternalDirectory } from "./external-directory"
-import { trimDiff } from "./edit"
-import { LSP } from "../lsp"
-import { Filesystem } from "../util/filesystem"
-import DESCRIPTION from "./apply_patch.txt"
-import { File } from "../file"
-import { Format } from "../format"
-
-const PatchParams = z.object({
-  patchText: z.string().describe("The full patch text that describes all changes to be made"),
-})
-
-export const ApplyPatchTool = Tool.define("apply_patch", {
-  description: DESCRIPTION,
-  parameters: PatchParams,
-  async execute(params, ctx) {
-    if (!params.patchText) {
-      throw new Error("patchText is required")
-    }
-
-    // Parse the patch to get hunks
-    let hunks: Patch.Hunk[]
-    try {
-      const parseResult = Patch.parsePatch(params.patchText)
-      hunks = parseResult.hunks
-    } catch (error) {
-      throw new Error(`apply_patch verification failed: ${error}`)
-    }
-
-    if (hunks.length === 0) {
-      const normalized = params.patchText.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim()
-      if (normalized === "*** Begin Patch\n*** End Patch") {
-        throw new Error("patch rejected: empty patch")
-      }
-      throw new Error("apply_patch verification failed: no hunks found")
-    }
-
-    // Validate file paths and check permissions
-    const fileChanges: Array<{
-      filePath: string
-      oldContent: string
-      newContent: string
-      type: "add" | "update" | "delete" | "move"
-      movePath?: string
-      diff: string
-      additions: number
-      deletions: number
-    }> = []
-
-    let totalDiff = ""
-
-    for (const hunk of hunks) {
-      const filePath = path.resolve(Instance.directory, hunk.path)
-      await assertExternalDirectory(ctx, filePath)
-
-      switch (hunk.type) {
-        case "add": {
-          const oldContent = ""
-          const newContent =
-            hunk.contents.length === 0 || hunk.contents.endsWith("\n") ? hunk.contents : `${hunk.contents}\n`
-          const diff = trimDiff(createTwoFilesPatch(filePath, filePath, oldContent, newContent))
-
-          let additions = 0
-          let deletions = 0
-          for (const change of diffLines(oldContent, newContent)) {
-            if (change.added) additions += change.count || 0
-            if (change.removed) deletions += change.count || 0
-          }
-
-          fileChanges.push({
-            filePath,
-            oldContent,
-            newContent,
-            type: "add",
-            diff,
-            additions,
-            deletions,
-          })
-
-          totalDiff += diff + "\n"
-          break
-        }
-
-        case "update": {
-          // Check if file exists for update
-          const stats = await fs.stat(filePath).catch(() => null)
-          if (!stats || stats.isDirectory()) {
-            throw new Error(`apply_patch verification failed: Failed to read file to update: ${filePath}`)
-          }
-
-          const oldContent = await fs.readFile(filePath, "utf-8")
-          let newContent = oldContent
-
-          // Apply the update chunks to get new content
-          try {
-            const fileUpdate = Patch.deriveNewContentsFromChunks(filePath, hunk.chunks)
-            newContent = fileUpdate.content
-          } catch (error) {
-            throw new Error(`apply_patch verification failed: ${error}`)
-          }
-
-          const diff = trimDiff(createTwoFilesPatch(filePath, filePath, oldContent, newContent))
-
-          let additions = 0
-          let deletions = 0
-          for (const change of diffLines(oldContent, newContent)) {
-            if (change.added) additions += change.count || 0
-            if (change.removed) deletions += change.count || 0
-          }
-
-          const movePath = hunk.move_path ? path.resolve(Instance.directory, hunk.move_path) : undefined
-          await assertExternalDirectory(ctx, movePath)
-
-          fileChanges.push({
-            filePath,
-            oldContent,
-            newContent,
-            type: hunk.move_path ? "move" : "update",
-            movePath,
-            diff,
-            additions,
-            deletions,
-          })
-
-          totalDiff += diff + "\n"
-          break
-        }
-
-        case "delete": {
-          const contentToDelete = await fs.readFile(filePath, "utf-8").catch((error) => {
-            throw new Error(`apply_patch verification failed: ${error}`)
-          })
-          const deleteDiff = trimDiff(createTwoFilesPatch(filePath, filePath, contentToDelete, ""))
-
-          const deletions = contentToDelete.split("\n").length
-
-          fileChanges.push({
-            filePath,
-            oldContent: contentToDelete,
-            newContent: "",
-            type: "delete",
-            diff: deleteDiff,
-            additions: 0,
-            deletions,
-          })
-
-          totalDiff += deleteDiff + "\n"
-          break
-        }
-      }
-    }
-
-    // Build per-file metadata for UI rendering (used for both permission and result)
-    const files = fileChanges.map((change) => ({
-      filePath: change.filePath,
-      relativePath: path.relative(Instance.worktree, change.movePath ?? change.filePath).replaceAll("\\", "/"),
-      type: change.type,
-      diff: change.diff,
-      before: change.oldContent,
-      after: change.newContent,
-      additions: change.additions,
-      deletions: change.deletions,
-      movePath: change.movePath,
-    }))
-
-    // Check permissions if needed
-    const relativePaths = fileChanges.map((c) => path.relative(Instance.worktree, c.filePath).replaceAll("\\", "/"))
-    await ctx.ask({
-      permission: "edit",
-      patterns: relativePaths,
-      always: ["*"],
-      metadata: {
-        filepath: relativePaths.join(", "),
-        diff: totalDiff,
-        files,
-      },
-    })
-
-    // Apply the changes
-    const updates: Array<{ file: string; event: "add" | "change" | "unlink" }> = []
-
-    for (const change of fileChanges) {
-      const edited = change.type === "delete" ? undefined : (change.movePath ?? change.filePath)
-      switch (change.type) {
-        case "add":
-          // Create parent directories (recursive: true is safe on existing/root dirs)
-          await fs.mkdir(path.dirname(change.filePath), { recursive: true })
-          await fs.writeFile(change.filePath, change.newContent, "utf-8")
-          updates.push({ file: change.filePath, event: "add" })
-          break
-
-        case "update":
-          await fs.writeFile(change.filePath, change.newContent, "utf-8")
-          updates.push({ file: change.filePath, event: "change" })
-          break
-
-        case "move":
-          if (change.movePath) {
-            // Create parent directories (recursive: true is safe on existing/root dirs)
-            await fs.mkdir(path.dirname(change.movePath), { recursive: true })
-            await fs.writeFile(change.movePath, change.newContent, "utf-8")
-            await fs.unlink(change.filePath)
-            updates.push({ file: change.filePath, event: "unlink" })
-            updates.push({ file: change.movePath, event: "add" })
-          }
-          break
-
-        case "delete":
-          await fs.unlink(change.filePath)
-          updates.push({ file: change.filePath, event: "unlink" })
-          break
-      }
-
-      if (edited) {
-        await Format.file(edited)
-        Bus.publish(File.Event.Edited, { file: edited })
-      }
-    }
-
-    // Publish file change events
-    for (const update of updates) {
-      await Bus.publish(FileWatcher.Event.Updated, update)
-    }
-
-    // Notify LSP of file changes and collect diagnostics
-    for (const change of fileChanges) {
-      if (change.type === "delete") continue
-      const target = change.movePath ?? change.filePath
-      await LSP.touchFile(target, true)
-    }
-    const diagnostics = await LSP.diagnostics()
-
-    // Generate output summary
-    const summaryLines = fileChanges.map((change) => {
-      if (change.type === "add") {
-        return `A ${path.relative(Instance.worktree, change.filePath).replaceAll("\\", "/")}`
-      }
-      if (change.type === "delete") {
-        return `D ${path.relative(Instance.worktree, change.filePath).replaceAll("\\", "/")}`
-      }
-      const target = change.movePath ?? change.filePath
-      return `M ${path.relative(Instance.worktree, target).replaceAll("\\", "/")}`
-    })
-    let output = `Success. Updated the following files:\n${summaryLines.join("\n")}`
-
-    // Report LSP errors for changed files
-    const MAX_DIAGNOSTICS_PER_FILE = 20
-    for (const change of fileChanges) {
-      if (change.type === "delete") continue
-      const target = change.movePath ?? change.filePath
-      const normalized = Filesystem.normalizePath(target)
-      const issues = diagnostics[normalized] ?? []
-      const errors = issues.filter((item) => item.severity === 1)
-      if (errors.length > 0) {
-        const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE)
-        const suffix =
-          errors.length > MAX_DIAGNOSTICS_PER_FILE ? `\n... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE} more` : ""
-        output += `\n\nLSP errors detected in ${path.relative(Instance.worktree, target).replaceAll("\\", "/")}, please fix:\n<diagnostics file="${target}">\n${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}\n</diagnostics>`
-      }
-    }
-
-    return {
-      title: output,
-      metadata: {
-        diff: totalDiff,
-        files,
-        diagnostics,
-      },
-      output,
-    }
-  },
-})