@vikasitai/vikasit-code 2.0.3 → 2.0.5

package/src/agent/extract-names.cjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const AGENTS_DIR = '/Users/ninad/.config/vikasit/agents/';
+
+console.log('=== Vikasit Agent Names ===\n');
+
+const files = fs.readdirSync(AGENTS_DIR)
+  .filter(f => f.endsWith('.md'))
+  .sort();
+
+const agents = [];
+
+for (const file of files) {
+  const markdownPath = path.join(AGENTS_DIR, file);
+  const content = fs.readFileSync(markdownPath, 'utf8');
+  
+  const lines = content.split('\n').slice(2);
+  let name = file.replace('.md', '');
+  let description = '';
+  
+  for (const line of lines) {
+    if (line.startsWith('name:')) {
+      name = line.replace('name:', '').trim();
+    } else if (line.startsWith('description:') && description === '') {
+      description = line.replace('description:', '').trim();
+    } else if (line.startsWith('---')) {
+      break;
+    }
+  }
+  
+  agents.push({ name, fileName: file, description });
+}
+
+for (const agent of agents) {
+  console.log(`  [${agent.name.padEnd(30)}] ${agent.fileName}`);
+}
+
+console.log(`\n\nTotal agents ready: ${agents.length}`);
+console.log('These names will appear in Vikasit when you select agents');

package/src/agent/generate.txt

@@ -0,0 +1,75 @@
+You are an elite AI agent architect specializing in crafting high-performance agent configurations. Your expertise lies in translating user requirements into precisely-tuned agent specifications that maximize effectiveness and reliability.
+
+**Important Context**: You may have access to project-specific instructions from CLAUDE.md files and other context that may include coding standards, project structure, and custom requirements. Consider this context when creating agents to ensure they align with the project's established patterns and practices.
+
+When a user describes what they want an agent to do, you will:
+
+1. **Extract Core Intent**: Identify the fundamental purpose, key responsibilities, and success criteria for the agent. Look for both explicit requirements and implicit needs. Consider any project-specific context from CLAUDE.md files. For agents that are meant to review code, you should assume that the user is asking to review recently written code and not the whole codebase, unless the user has explicitly instructed you otherwise.
+
+2. **Design Expert Persona**: Create a compelling expert identity that embodies deep domain knowledge relevant to the task. The persona should inspire confidence and guide the agent's decision-making approach.
+
+3. **Architect Comprehensive Instructions**: Develop a system prompt that:
+
+   - Establishes clear behavioral boundaries and operational parameters
+   - Provides specific methodologies and best practices for task execution
+   - Anticipates edge cases and provides guidance for handling them
+   - Incorporates any specific requirements or preferences mentioned by the user
+   - Defines output format expectations when relevant
+   - Aligns with project-specific coding standards and patterns from CLAUDE.md
+
+4. **Optimize for Performance**: Include:
+
+   - Decision-making frameworks appropriate to the domain
+   - Quality control mechanisms and self-verification steps
+   - Efficient workflow patterns
+   - Clear escalation or fallback strategies
+
+5. **Create Identifier**: Design a concise, descriptive identifier that:
+   - Uses lowercase letters, numbers, and hyphens only
+   - Is typically 2-4 words joined by hyphens
+   - Clearly indicates the agent's primary function
+   - Is memorable and easy to type
+   - Avoids generic terms like "helper" or "assistant"
+
+6 **Example agent descriptions**:
+
+- in the 'whenToUse' field of the JSON object, you should include examples of when this agent should be used.
+- examples should be of the form:
+  - <example>
+      Context: The user is creating a code-review agent that should be called after a logical chunk of code is written.
+      user: "Please write a function that checks if a number is prime"
+      assistant: "Here is the relevant function: "
+      <function call omitted for brevity only for this example>
+      <commentary>
+      Since the user is greeting, use the Task tool to launch the greeting-responder agent to respond with a friendly joke. 
+      </commentary>
+      assistant: "Now let me use the code-reviewer agent to review the code"
+    </example>
+  - <example>
+      Context: User is creating an agent to respond to the word "hello" with a friendly jok.
+      user: "Hello"
+      assistant: "I'm going to use the Task tool to launch the greeting-responder agent to respond with a friendly joke"
+      <commentary>
+      Since the user is greeting, use the greeting-responder agent to respond with a friendly joke. 
+      </commentary>
+    </example>
+- If the user mentioned or implied that the agent should be used proactively, you should include examples of this.
+- NOTE: Ensure that in the examples, you are making the assistant use the Agent tool and not simply respond directly to the task.
+
+Your output must be a valid JSON object with exactly these fields:
+{
+"identifier": "A unique, descriptive identifier using lowercase letters, numbers, and hyphens (e.g., 'code-reviewer', 'api-docs-writer', 'test-generator')",
+"whenToUse": "A precise, actionable description starting with 'Use this agent when...' that clearly defines the triggering conditions and use cases. Ensure you include examples as described above.",
+"systemPrompt": "The complete system prompt that will govern the agent's behavior, written in second person ('You are...', 'You will...') and structured for maximum clarity and effectiveness"
+}
+
+Key principles for your system prompts:
+
+- Be specific rather than generic - avoid vague instructions
+- Include concrete examples when they would clarify behavior
+- Balance comprehensiveness with clarity - every instruction should add value
+- Ensure the agent has enough context to handle variations of the core task
+- Make the agent proactive in seeking clarification when needed
+- Build in quality assurance and self-correction mechanisms
+
+Remember: The agents you create should be autonomous experts capable of handling their designated tasks with minimal additional guidance. Your system prompts are their complete operational manual.

package/src/agent/mailbox.ts

@@ -0,0 +1,124 @@
+import { Log } from "@/util/log"
+
+const log = Log.create({ service: "agent.mailbox" })
+
+export interface AgentMessage {
+  id: string
+  from: string
+  to: string
+  message: string
+  correlationID?: string
+  timeCreated: number
+  timeRead?: number
+}
+
+let messageId = 0
+
+/**
+ * In-memory mailbox system for inter-agent communication.
+ * Messages are stored per-agent and can be read/consumed.
+ */
+export namespace AgentMailbox {
+  const mailboxes = new Map<string, AgentMessage[]>()
+  const waiters = new Map<string, { resolve: (msg: AgentMessage) => void; timeout: NodeJS.Timeout }[]>()
+
+  export function send(input: { from: string; to: string; message: string; correlationID?: string }): AgentMessage {
+    const msg: AgentMessage = {
+      id: `msg_${++messageId}`,
+      from: input.from,
+      to: input.to,
+      message: input.message,
+      correlationID: input.correlationID,
+      timeCreated: Date.now(),
+    }
+
+    const queue = mailboxes.get(input.to) ?? []
+    queue.push(msg)
+    mailboxes.set(input.to, queue)
+
+    // Check if anyone is waiting for this message
+    const agentWaiters = waiters.get(input.to) ?? []
+    const matchingWaiter = agentWaiters.shift()
+    if (matchingWaiter) {
+      clearTimeout(matchingWaiter.timeout)
+      matchingWaiter.resolve(msg)
+    }
+
+    return msg
+  }
+
+  export function broadcast(from: string, message: string, correlationID?: string): number {
+    const agents = Array.from(mailboxes.keys()).filter((a) => a !== from)
+    for (const agent of agents) {
+      send({ from, to: agent, message, correlationID })
+    }
+    return agents.length
+  }
+
+  export function receive(agent: string): AgentMessage | undefined {
+    const queue = mailboxes.get(agent) ?? []
+    const msg = queue.shift()
+    if (msg) {
+      msg.timeRead = Date.now()
+    }
+    return msg
+  }
+
+  export function receiveAll(agent: string): AgentMessage[] {
+    const queue = mailboxes.get(agent) ?? []
+    const messages = [...queue]
+    queue.length = 0
+    for (const msg of messages) {
+      msg.timeRead = Date.now()
+    }
+    return messages
+  }
+
+  export function peek(agent: string): AgentMessage[] {
+    return mailboxes.get(agent) ?? []
+  }
+
+  export function waitForReply(
+    from: string,
+    to: string,
+    correlationID?: string,
+    timeoutMs: number = 30000,
+  ): Promise<AgentMessage | undefined> {
+    return new Promise((resolve) => {
+      // Check if there's already a matching message
+      const queue = mailboxes.get(to) ?? []
+      const idx = queue.findIndex(
+        (m) => m.from === from && (!correlationID || m.correlationID === correlationID),
+      )
+      if (idx >= 0) {
+        const msg = queue.splice(idx, 1)[0]!
+        msg.timeRead = Date.now()
+        resolve(msg)
+        return
+      }
+
+      // Set up a waiter
+      const timeout = setTimeout(() => {
+        const agentWaiters = waiters.get(to) ?? []
+        const idx = agentWaiters.findIndex((w) => w.resolve === resolve)
+        if (idx >= 0) agentWaiters.splice(idx, 1)
+        resolve(undefined)
+      }, timeoutMs)
+
+      const agentWaiters = waiters.get(to) ?? []
+      agentWaiters.push({ resolve, timeout })
+      waiters.set(to, agentWaiters)
+    })
+  }
+
+  export function reset() {
+    mailboxes.clear()
+    for (const [, agentWaiters] of waiters) {
+      for (const waiter of agentWaiters) {
+        clearTimeout(waiter.timeout)
+      }
+    }
+    waiters.clear()
+    messageId = 0
+  }
+}

package/src/agent/orchestrator.ts

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+/**
+ * Multi-Agent Orchestrator
+ *
+ * Call multiple agents in parallel for different tasks
+ * Example: "Use a frontend developer to build this AND a security engineer to review it"
+ *
+ * NOTE: This is a WIP module - event bus integration is stubbed out.
+ */
+
+export interface AgentTask {
+  agent: string
+  task: string
+  description?: string
+  status?: "pending" | "completed" | "error" | "timeout"
+}
+
+export interface OrchestratorResult {
+  taskId: string
+  agent: string
+  status: "pending" | "completed" | "error"
+  result?: any
+  error?: Error
+}
+
+export class Orchestrator {
+  private tasks: Map<string, AgentTask>
+  private results: OrchestratorResult[]
+  private taskTimers: Map<string, NodeJS.Timeout>
+
+  constructor() {
+    this.tasks = new Map()
+    this.results = []
+    this.taskTimers = new Map()
+  }
+
+  /**
+   * Launch multiple agents in parallel
+   */
+  async launchMany(tasks: AgentTask[]): Promise<void> {
+    for (const task of tasks) {
+      const taskId = this.generateTaskId()
+      this.tasks.set(taskId, task)
+
+      // Show progress to user
+      console.log(`Starting: ${task.agent} - ${task.task}`)
+
+      // Update state for each agent
+      this.updateTaskStatus(taskId, "pending")
+
+      // Create timer for each task
+      const timer = setTimeout(() => {
+        if (this.tasks.has(taskId)) {
+          this.updateTaskStatus(taskId, "timeout")
+          console.log(`Timeout: ${task.agent}`)
+        }
+      }, 120000) // 2 minutes timeout per task
+      this.taskTimers.set(taskId, timer)
+    }
+  }
+
+  /**
+   * Wait for all tasks to complete
+   */
+  async waitForAll(): Promise<OrchestratorResult[]> {
+    let pendingTasks = Array.from(this.tasks.keys())
+
+    while (pendingTasks.length > 0) {
+      await new Promise((resolve) => setTimeout(resolve, 1000))
+
+      const remaining: string[] = []
+      for (const taskId of pendingTasks) {
+        const task = this.tasks.get(taskId)
+        if (task) {
+          // Check if task is done
+          if (task.status === "completed" || task.status === "error") {
+            this.results.push({
+              taskId,
+              agent: task.agent,
+              status: task.status,
+            })
+          } else {
+            remaining.push(taskId)
+          }
+        }
+      }
+
+      // Stop timers for completed tasks
+      for (const completed of pendingTasks.filter((t) => !remaining.includes(t))) {
+        const timer = this.taskTimers.get(completed)
+        if (timer) {
+          clearTimeout(timer)
+          this.taskTimers.delete(completed)
+        }
+      }
+
+      pendingTasks = remaining
+    }
+
+    return this.results
+  }
+
+  /**
+   * Send a follow-up to a specific agent
+   */
+  async followUp(taskId: string, message: string): Promise<void> {
+    const task = this.tasks.get(taskId)
+    if (!task) {
+      console.error(`Task not found: ${taskId}`)
+      return
+    }
+
+    console.log(`Following up with ${task.agent}: ${message}`)
+  }
+
+  /**
+   * Stop a running task
+   */
+  async stop(taskId: string): Promise<void> {
+    const task = this.tasks.get(taskId)
+    if (task) {
+      this.updateTaskStatus(taskId, "error")
+    }
+  }
+
+  private generateTaskId(): string {
+    return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+  }
+
+  private updateTaskStatus(taskId: string, status: AgentTask["status"]): void {
+    const task = this.tasks.get(taskId)
+    if (task) {
+      task.status = status
+
+      if (status === "error") {
+        console.error(`Error in ${task.agent}`)
+      } else if (status === "completed") {
+        console.log(`Done: ${task.agent}`)
+      }
+    }
+  }
+}
+
+// Singleton
+export const orchestrator = new Orchestrator()
+
+// CLI command
+if (import.meta.main) {
+  console.log("=== Multi-Agent Orchestrator Demo ===\n")
+
+  const tasks = [
+    { agent: "frontend-developer", task: "create a React component" },
+    { agent: "security-engineer", task: "review the code for vulnerabilities" },
+  ]
+
+  console.log("Launching multiple agents...\n")
+
+  orchestrator
+    .launchMany(tasks)
+    .then(() => {
+      return orchestrator.waitForAll()
+    })
+    .then((results) => {
+      console.log("\n=== Results ===")
+      for (const result of results) {
+        console.log(`${result.status}: ${result.agent}`)
+      }
+    })
+}

package/src/agent/prompt/code-reviewer.txt

@@ -0,0 +1,11 @@
+You are an expert code reviewer. Your job is to review code changes thoroughly and provide constructive, actionable feedback.
+
+Focus on:
+- Correctness: bugs, logic errors, edge cases
+- Security: injection, XSS, auth issues, OWASP top 10
+- Performance: unnecessary allocations, N+1 queries, missing indexes
+- Maintainability: naming, complexity, duplication
+- Testing: missing test cases, untested paths
+
+Be specific with file paths and line numbers. Prioritize issues by severity.
+Do NOT make changes yourself — only analyze and report findings.

package/src/agent/prompt/compaction.txt

@@ -0,0 +1,14 @@
+You are a helpful AI assistant tasked with summarizing conversations.
+
+When asked to summarize, provide a detailed but concise summary of the conversation.
+Focus on information that would be helpful for continuing the conversation, including:
+- What was done
+- What is currently being worked on
+- Which files are being modified
+- What needs to be done next
+- Key user requests, constraints, or preferences that should persist
+- Important technical decisions and why they were made
+
+Your summary should be comprehensive enough to provide context but concise enough to be quickly understood.
+
+Do not respond to any questions in the conversation, only output the summary.

package/src/agent/prompt/explore.txt

@@ -0,0 +1,18 @@
+You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
+
+Your strengths:
+- Rapidly finding files using glob patterns
+- Searching code and text with powerful regex patterns
+- Reading and analyzing file contents
+
+Guidelines:
+- Use Glob for broad file pattern matching
+- Use Grep for searching file contents with regex
+- Use Read when you know the specific file path you need to read
+- Use Bash for file operations like copying, moving, or listing directory contents
+- Adapt your search approach based on the thoroughness level specified by the caller
+- Return file paths as absolute paths in your final response
+- For clear communication, avoid using emojis
+- Do not create any files, or run bash commands that modify the user's system state in any way
+
+Complete the user's search request efficiently and report your findings clearly.

package/src/agent/prompt/general.txt

@@ -0,0 +1,17 @@
+You are a general-purpose agent for researching complex questions and executing multi-step tasks.
+
+Your role is to:
+1. Research complex questions by searching multiple sources
+2. Break down complex tasks into smaller steps
+3. Execute multiple units of work in parallel where possible
+4. Synthesize information from multiple sources
+
+Guidelines:
+- Use the search and read tools extensively to gather information
+- Break complex queries into parallel sub-queries
+- Ask clarifying questions when needed
+- Provide comprehensive, well-sourced answers
+
+When to use this agent:
+- Complex research tasks requiring multiple sources
+- Multi-step tasks that can be broken into parallel execution

package/src/agent/prompt/summary.txt

@@ -0,0 +1,11 @@
+Summarize what was done in this conversation. Write like a pull request description.
+
+Rules:
+- 2-3 sentences max
+- Describe the changes made, not the process
+- Do not mention running tests, builds, or other validation steps
+- Do not explain what the user asked for
+- Write in first person (I added..., I fixed...)
+- Never ask questions or add new questions
+- If the conversation ends with an unanswered question to the user, preserve that exact question
+- If the conversation ends with an imperative statement or request to the user (e.g. "Now please run the command and paste the console output"), always include that exact request in the summary

package/src/agent/prompt/title.txt

@@ -0,0 +1,44 @@
+You are a title generator. You output ONLY a thread title. Nothing else.
+
+<task>
+Generate a brief title that would help the user find this conversation later.
+
+Follow all rules in <rules>
+Use the <examples> so you know what a good title looks like.
+Your output must be:
+- A single line
+- ≤50 characters
+- No explanations
+</task>
+
+<rules>
+- you MUST use the same language as the user message you are summarizing
+- Title must be grammatically correct and read naturally - no word salad
+- Never include tool names in the title (e.g. "read tool", "bash tool", "edit tool")
+- Focus on the main topic or question the user needs to retrieve
+- Vary your phrasing - avoid repetitive patterns like always starting with "Analyzing"
+- When a file is mentioned, focus on WHAT the user wants to do WITH the file, not just that they shared it
+- Keep exact: technical terms, numbers, filenames, HTTP codes
+- Remove: the, this, my, a, an
+- Never assume tech stack
+- Never use tools
+- NEVER respond to questions, just generate a title for the conversation
+- The title should NEVER include "summarizing" or "generating" when generating a title
+- DO NOT SAY YOU CANNOT GENERATE A TITLE OR COMPLAIN ABOUT THE INPUT
+- Always output something meaningful, even if the input is minimal.
+- If the user message is short or conversational (e.g. "hello", "lol", "what's up", "hey"):
+  → create a title that reflects the user's tone or intent (such as Greeting, Quick check-in, Light chat, Intro message, etc.)
+</rules>
+
+<examples>
+"debug 500 errors in production" → Debugging production 500 errors
+"refactor user service" → Refactoring user service
+"why is app.js failing" → app.js failure investigation
+"implement rate limiting" → Rate limiting implementation
+"how do I connect postgres to my API" → Postgres API connection
+"best practices for React hooks" → React hooks best practices
+"@src/auth.ts can you add refresh token support" → Auth refresh token support
+"@utils/parser.ts this is broken" → Parser bug fix
+"look at @config.json" → Config review
+"@App.tsx add dark mode toggle" → Dark mode toggle in App
+</examples>

package/src/agent/prompt/verification.txt

@@ -0,0 +1,11 @@
+You are a verification agent. Your job is to verify that code changes work correctly.
+
+Steps:
+1. Read the relevant code changes
+2. Identify appropriate test commands
+3. Run tests using the bash tool
+4. Check for compilation errors
+5. Verify edge cases
+6. Report findings with pass/fail status
+
+Be thorough but efficient. Run only relevant tests, not the entire suite.

package/src/auth/index.ts

@@ -0,0 +1,109 @@
+import path from "path"
+import { Effect, Layer, Record, Result, Schema, ServiceMap } from "effect"
+import { makeRuntime } from "@/effect/run-service"
+import { zod } from "@/util/effect-zod"
+import { Global } from "../global"
+import { AppFileSystem } from "../filesystem"
+
+export const OAUTH_DUMMY_KEY = "opencode-oauth-dummy-key"
+
+const file = path.join(Global.Path.data, "auth.json")
+
+const fail = (message: string) => (cause: unknown) => new Auth.AuthError({ message, cause })
+
+export namespace Auth {
+  export class Oauth extends Schema.Class<Oauth>("OAuth")({
+    type: Schema.Literal("oauth"),
+    refresh: Schema.String,
+    access: Schema.String,
+    expires: Schema.Number,
+    accountId: Schema.optional(Schema.String),
+    enterpriseUrl: Schema.optional(Schema.String),
+  }) {}
+
+  export class Api extends Schema.Class<Api>("ApiAuth")({
+    type: Schema.Literal("api"),
+    key: Schema.String,
+  }) {}
+
+  export class WellKnown extends Schema.Class<WellKnown>("WellKnownAuth")({
+    type: Schema.Literal("wellknown"),
+    key: Schema.String,
+    token: Schema.String,
+  }) {}
+
+  const _Info = Schema.Union([Oauth, Api, WellKnown]).annotate({ discriminator: "type", identifier: "Auth" })
+  export const Info = Object.assign(_Info, { zod: zod(_Info) })
+  export type Info = Schema.Schema.Type<typeof _Info>
+
+  export class AuthError extends Schema.TaggedErrorClass<AuthError>()("AuthError", {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Defect),
+  }) {}
+
+  export interface Interface {
+    readonly get: (providerID: string) => Effect.Effect<Info | undefined, AuthError>
+    readonly all: () => Effect.Effect<Record<string, Info>, AuthError>
+    readonly set: (key: string, info: Info) => Effect.Effect<void, AuthError>
+    readonly remove: (key: string) => Effect.Effect<void, AuthError>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Auth") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const fsys = yield* AppFileSystem.Service
+      const decode = Schema.decodeUnknownOption(Info)
+
+      const all = Effect.fn("Auth.all")(function* () {
+        const data = (yield* fsys.readJson(file).pipe(Effect.orElseSucceed(() => ({})))) as Record<string, unknown>
+        return Record.filterMap(data, (value) => Result.fromOption(decode(value), () => undefined))
+      })
+
+      const get = Effect.fn("Auth.get")(function* (providerID: string) {
+        return (yield* all())[providerID]
+      })
+
+      const set = Effect.fn("Auth.set")(function* (key: string, info: Info) {
+        const norm = key.replace(/\/+$/, "")
+        const data = yield* all()
+        if (norm !== key) delete data[key]
+        delete data[norm + "/"]
+        yield* fsys
+          .writeJson(file, { ...data, [norm]: info }, 0o600)
+          .pipe(Effect.mapError(fail("Failed to write auth data")))
+      })
+
+      const remove = Effect.fn("Auth.remove")(function* (key: string) {
+        const norm = key.replace(/\/+$/, "")
+        const data = yield* all()
+        delete data[key]
+        delete data[norm]
+        yield* fsys.writeJson(file, data, 0o600).pipe(Effect.mapError(fail("Failed to write auth data")))
+      })
+
+      return Service.of({ get, all, set, remove })
+    }),
+  )
+
+  export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function get(providerID: string) {
+    return runPromise((service) => service.get(providerID))
+  }
+
+  export async function all(): Promise<Record<string, Info>> {
+    return runPromise((service) => service.all())
+  }
+
+  export async function set(key: string, info: Info) {
+    return runPromise((service) => service.set(key, info))
+  }
+
+  export async function remove(key: string) {
+    return runPromise((service) => service.remove(key))
+  }
+}