@vikasitai/vikasit-code 2.0.7 → 2.0.8

package/src/util/rpc.ts

@@ -1,66 +0,0 @@
-export namespace Rpc {
-  type Definition = {
-    [method: string]: (input: any) => any
-  }
-
-  export function listen(rpc: Definition) {
-    onmessage = async (evt) => {
-      const parsed = JSON.parse(evt.data)
-      if (parsed.type === "rpc.request") {
-        const result = await rpc[parsed.method](parsed.input)
-        postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
-      }
-    }
-  }
-
-  export function emit(event: string, data: unknown) {
-    postMessage(JSON.stringify({ type: "rpc.event", event, data }))
-  }
-
-  export function client<T extends Definition>(target: {
-    postMessage: (data: string) => void | null
-    onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
-  }) {
-    const pending = new Map<number, (result: any) => void>()
-    const listeners = new Map<string, Set<(data: any) => void>>()
-    let id = 0
-    target.onmessage = async (evt) => {
-      const parsed = JSON.parse(evt.data)
-      if (parsed.type === "rpc.result") {
-        const resolve = pending.get(parsed.id)
-        if (resolve) {
-          resolve(parsed.result)
-          pending.delete(parsed.id)
-        }
-      }
-      if (parsed.type === "rpc.event") {
-        const handlers = listeners.get(parsed.event)
-        if (handlers) {
-          for (const handler of handlers) {
-            handler(parsed.data)
-          }
-        }
-      }
-    }
-    return {
-      call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
-        const requestId = id++
-        return new Promise((resolve) => {
-          pending.set(requestId, resolve)
-          target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
-        })
-      },
-      on<Data>(event: string, handler: (data: Data) => void) {
-        let handlers = listeners.get(event)
-        if (!handlers) {
-          handlers = new Set()
-          listeners.set(event, handlers)
-        }
-        handlers.add(handler)
-        return () => {
-          handlers!.delete(handler)
-        }
-      },
-    }
-  }
-}

package/src/util/schema.ts

@@ -1,53 +0,0 @@
-import { Schema } from "effect"
-
-/**
- * Attach static methods to a schema object. Designed to be used with `.pipe()`:
- *
- * @example
- *   export const Foo = fooSchema.pipe(
- *     withStatics((schema) => ({
- *       zero: schema.makeUnsafe(0),
- *       from: Schema.decodeUnknownOption(schema),
- *     }))
- *   )
- */
-export const withStatics =
-  <S extends object, M extends Record<string, unknown>>(methods: (schema: S) => M) =>
-  (schema: S): S & M =>
-    Object.assign(schema, methods(schema))
-
-declare const NewtypeBrand: unique symbol
-type NewtypeBrand<Tag extends string> = { readonly [NewtypeBrand]: Tag }
-
-/**
- * Nominal wrapper for scalar types. The class itself is a valid schema —
- * pass it directly to `Schema.decode`, `Schema.decodeEffect`, etc.
- *
- * @example
- *   class QuestionID extends Newtype<QuestionID>()("QuestionID", Schema.String) {
- *     static make(id: string): QuestionID {
- *       return this.makeUnsafe(id)
- *     }
- *   }
- *
- *   Schema.decodeEffect(QuestionID)(input)
- */
-export function Newtype<Self>() {
-  return <const Tag extends string, S extends Schema.Top>(tag: Tag, schema: S) => {
-    type Branded = NewtypeBrand<Tag>
-
-    abstract class Base {
-      declare readonly [NewtypeBrand]: Tag
-
-      static makeUnsafe(value: Schema.Schema.Type<S>): Self {
-        return value as unknown as Self
-      }
-    }
-
-    Object.setPrototypeOf(Base, schema)
-
-    return Base as unknown as (abstract new (_: never) => Branded) & {
-      readonly makeUnsafe: (value: Schema.Schema.Type<S>) => Self
-    } & Omit<Schema.Opaque<Self, S, {}>, "makeUnsafe">
-  }
-}

package/src/util/scrap.ts

@@ -1,10 +0,0 @@
-export const foo: string = "42"
-export const bar: number = 123
-
-export function dummyFunction(): void {
-  console.log("This is a dummy function")
-}
-
-export function randomHelper(): boolean {
-  return Math.random() > 0.5
-}

package/src/util/signal.ts

@@ -1,12 +0,0 @@
-export function signal() {
-  let resolve: any
-  const promise = new Promise((r) => (resolve = r))
-  return {
-    trigger() {
-      return resolve()
-    },
-    wait() {
-      return promise
-    },
-  }
-}

package/src/util/timeout.ts

@@ -1,14 +0,0 @@
-export function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
-  let timeout: NodeJS.Timeout
-  return Promise.race([
-    promise.then((result) => {
-      clearTimeout(timeout)
-      return result
-    }),
-    new Promise<never>((_, reject) => {
-      timeout = setTimeout(() => {
-        reject(new Error(`Operation timed out after ${ms}ms`))
-      }, ms)
-    }),
-  ])
-}

package/src/util/token.ts

@@ -1,7 +0,0 @@
-export namespace Token {
-  const CHARS_PER_TOKEN = 4
-
-  export function estimate(input: string) {
-    return Math.max(0, Math.round((input || "").length / CHARS_PER_TOKEN))
-  }
-}

package/src/util/update-schema.ts

@@ -1,13 +0,0 @@
-import z from "zod"
-
-export function updateSchema<T extends z.ZodRawShape>(schema: z.ZodObject<T>) {
-  const next = {} as {
-    [K in keyof T]: z.ZodOptional<z.ZodNullable<T[K]>>
-  }
-
-  for (const [k, v] of Object.entries(schema.required().shape) as [keyof T & string, z.ZodTypeAny][]) {
-    next[k] = v.nullable() as unknown as (typeof next)[typeof k]
-  }
-
-  return z.object(next)
-}

package/src/util/which.ts

@@ -1,14 +0,0 @@
-import whichPkg from "which"
-import path from "path"
-import { Global } from "../global"
-
-export function which(cmd: string, env?: NodeJS.ProcessEnv) {
-  const base = env?.PATH ?? env?.Path ?? process.env.PATH ?? process.env.Path ?? ""
-  const full = base ? base + path.delimiter + Global.Path.bin : Global.Path.bin
-  const result = whichPkg.sync(cmd, {
-    nothrow: true,
-    path: full,
-    pathExt: env?.PATHEXT ?? env?.PathExt ?? process.env.PATHEXT ?? process.env.PathExt,
-  })
-  return typeof result === "string" ? result : null
-}

package/src/util/wildcard.ts

@@ -1,59 +0,0 @@
-import { sortBy, pipe } from "remeda"
-
-export namespace Wildcard {
-  export function match(str: string, pattern: string) {
-    if (str) str = str.replaceAll("\\", "/")
-    if (pattern) pattern = pattern.replaceAll("\\", "/")
-    let escaped = pattern
-      .replace(/[.+^${}()|[\]\\]/g, "\\$&") // escape special regex chars
-      .replace(/\*/g, ".*") // * becomes .*
-      .replace(/\?/g, ".") // ? becomes .
-
-    // If pattern ends with " *" (space + wildcard), make the trailing part optional
-    // This allows "ls *" to match both "ls" and "ls -la"
-    if (escaped.endsWith(" .*")) {
-      escaped = escaped.slice(0, -3) + "( .*)?"
-    }
-
-    const flags = process.platform === "win32" ? "si" : "s"
-    return new RegExp("^" + escaped + "$", flags).test(str)
-  }
-
-  export function all(input: string, patterns: Record<string, any>) {
-    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
-    let result = undefined
-    for (const [pattern, value] of sorted) {
-      if (match(input, pattern)) {
-        result = value
-        continue
-      }
-    }
-    return result
-  }
-
-  export function allStructured(input: { head: string; tail: string[] }, patterns: Record<string, any>) {
-    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
-    let result = undefined
-    for (const [pattern, value] of sorted) {
-      const parts = pattern.split(/\s+/)
-      if (!match(input.head, parts[0])) continue
-      if (parts.length === 1 || matchSequence(input.tail, parts.slice(1))) {
-        result = value
-        continue
-      }
-    }
-    return result
-  }
-
-  function matchSequence(items: string[], patterns: string[]): boolean {
-    if (patterns.length === 0) return true
-    const [pattern, ...rest] = patterns
-    if (pattern === "*") return matchSequence(items, rest)
-    for (let i = 0; i < items.length; i++) {
-      if (match(items[i], pattern) && matchSequence(items.slice(i + 1), rest)) {
-        return true
-      }
-    }
-    return false
-  }
-}

package/src/vim/agent-namer.ts

@@ -1,86 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "fs"
-import path from "path"
-
-interface AgentInfo {
-  fullName: string
-  longName: string
-  shortName: string
-}
-
-export function extractAgentName(agentFile: string): AgentInfo | null {
-  try {
-    if (!fs.existsSync(agentFile)) {
-      return null
-    }
-
-    const markdownPath = agentFile.endsWith(".md") ? agentFile : path.join(agentFile, "SKILL.md")
-    if (!fs.existsSync(markdownPath)) {
-      return null
-    }
-
-    const content = fs.readFileSync(markdownPath, "utf8")
-
-    const frontmatterMatch = content.match(/^(---\n.*?---\n)/s)
-    if (!frontmatterMatch) {
-      return null
-    }
-
-    const yamlBody = frontmatterMatch[0].replace(/^---\n|^---\n/g, "")
-    const lines = yamlBody.split("\n")
-    const parsed: any = {}
-
-    for (const line of lines) {
-      const match = line.match(/^([^:]+):\s*(.*)$/)
-      if (match) {
-        parsed[match[1].trim()] = match[2].trim()
-      }
-    }
-
-    const name = parsed.name
-    if (!name) {
-      return null
-    }
-
-    const longName = name.length > 50 ? `${name.substring(0, 47)}...` : name
-
-    return {
-      fullName: name,
-      longName: name.length > 18 ? name : name,
-      shortName: name.length > 30 ? `${name.substring(0, 27)}...` : name,
-    }
-  } catch (error) {
-    return null
-  }
-}
-
-interface Data {
-  name: string
-  description: string
-  mode?: string
-  color?: string
-}
-
-if (import.meta.main) {
-  const agentsDir = "/Users/ninad/.config/vikasit/agents/"
-
-  if (fs.existsSync(agentsDir)) {
-    const files = fs
-      .readdirSync(agentsDir)
-      .filter((f) => f.endsWith(".md"))
-      .sort()
-
-    console.log(`Found ${files.length} agent(s):\n`)
-
-    for (const file of files.slice(0, 10)) {
-      const fullPath = path.join(agentsDir, file)
-      const nameInfo = extractAgentName(fullPath)
-      if (nameInfo) {
-        console.log(`  [${nameInfo.longName.padEnd(30)}] ${file}`)
-      }
-    }
-  } else {
-    console.log("Agents directory not found")
-  }
-}

package/src/vim/types.ts

@@ -1,29 +0,0 @@
-/**
- * Vim Mode State Machine Types
- */
-
-export type Operator = "delete" | "change" | "yank"
-
-export type FindType = "f" | "F" | "t" | "T"
-
-export type TextObjScope = "inner" | "around"
-
-export type VimState =
-  | { mode: "INSERT"; insertedText: string }
-  | {
-      mode: "NORMAL"
-      state: null | "idle" | "operator" | "count" | "find" | "g-key" | "replace" | "indent"
-    }
-  | {
-      mode: "OPERATOR"
-      operator: Operator
-      count: number
-      textObjScope: TextObjScope
-    }
-  | {
-      mode: "FIND"
-      findType: FindType
-      direction: "forward" | "backward"
-      searchChar: string
-    }
-  | { mode: "REPLACE" }