@alumbwe/anvil 1.0.0

package/src/commands/prompt-builders.ts

@@ -0,0 +1,100 @@
+/**
+ * Centralized prompt builders for /plan and /review commands.
+ * This ensures consistent behavior regardless of entry path. Both run on the
+ * user's currently selected model.
+ */
+
+// Base prompts - both always gather context first.
+const PLAN_BASE_PROMPT =
+  'Gather all the relevant context and then think carefully about how to implement the following:'
+const REVIEW_BASE_PROMPT =
+  'Please gather all relevant context and then carefully review:'
+
+/**
+ * Build a plan prompt from user input.
+ * @param input - The user's plan request (e.g., "add OAuth login")
+ * @returns The full prompt to send to the agent
+ */
+export function buildPlanPrompt(input: string): string {
+  const trimmedInput = input.trim()
+  if (!trimmedInput) {
+    return PLAN_BASE_PROMPT
+  }
+  return `${PLAN_BASE_PROMPT}\n\n${trimmedInput}`
+}
+
+// Base prompt for interview command - asks clarifying questions before acting
+export const INTERVIEW_BASE_PROMPT = 'Interview me to better understand my request and then create a spec file. First, gather any relevant context (read files, do research, etc.). Then, use several rounds of the ask_user tool to ask non-obvious clarifying questions — things you cannot easily infer from the codebase or my initial message. Ask about edge cases, preferences, constraints, and design decisions. All questions should be directed through the ask_user tool -- not written out as text. Keep coming up with new questions that get at unique aspects of the request. Aim for at least **3 rounds** with multiple questions each round. When satisfied, write a [INSERT_REQUEST_SHORT_NAME]-spec.md file with all the information you have gathered about the request. Aim for as much detail as possible. You should NOT make any code changes yet. Stop after creating the spec file. End by using the suggest_followups tool with ways to flesh out the spec file. Here is my request:'
+
+/**
+ * Build an interview prompt from user input.
+ * @param input - The user's request to be interviewed about
+ * @returns The full prompt to send to the agent
+ */
+export function buildInterviewPrompt(input: string): string {
+  const trimmedInput = input.trim()
+  if (!trimmedInput) {
+    return INTERVIEW_BASE_PROMPT
+  }
+  return `${INTERVIEW_BASE_PROMPT}\n\n${trimmedInput}`
+}
+
+/**
+ * Review scope presets for the review screen.
+ */
+type ReviewScope = 'conversation' | 'uncommitted' | 'branch' | 'custom'
+
+/**
+ * Get the default text for a review scope preset.
+ */
+function getReviewScopeText(scope: ReviewScope): string {
+  switch (scope) {
+    case 'conversation':
+      return 'all changes made in this conversation'
+    case 'uncommitted':
+      return 'uncommitted changes'
+    case 'branch':
+      return 'this branch compared to main'
+    case 'custom':
+      return ''
+  }
+}
+
+/**
+ * Build a review prompt from scope or custom input.
+ * @param scope - The selected review scope (conversation, uncommitted, branch, or custom)
+ * @param customInput - Optional custom review focus (when scope is 'custom')
+ * @returns The full prompt to send to the agent
+ */
+export function buildReviewPrompt(
+  scope: ReviewScope,
+  customInput?: string,
+): string {
+  const scopeText = getReviewScopeText(scope)
+
+  // For custom input, append the user's specific focus
+  if (scope === 'custom' && customInput?.trim()) {
+    return `${REVIEW_BASE_PROMPT} ${customInput.trim()}`
+  }
+
+  // For preset scopes, use the scope text
+  if (scopeText) {
+    return `${REVIEW_BASE_PROMPT} ${scopeText}`
+  }
+
+  // Fallback for custom with no input
+  return REVIEW_BASE_PROMPT
+}
+
+/**
+ * Build a review prompt from direct argument (e.g., /review foo).
+ * This is used when the user provides review text directly after the command.
+ * @param input - The user's review request
+ * @returns The full prompt to send to the agent
+ */
+export function buildReviewPromptFromArgs(input: string): string {
+  const trimmedInput = input.trim()
+  // Use the same format as preset scopes for consistency
+  return `${REVIEW_BASE_PROMPT} ${trimmedInput}`
+}
+

package/src/commands/publish.ts

@@ -0,0 +1,203 @@
+import { WEBSITE_URL } from '@anvil/sdk'
+
+import { getUserCredentials } from '../utils/auth'
+import { getApiClient, setApiClientAuthToken } from '../utils/anvil-api'
+import { loadAgentDefinitions, getLoadedAgentsData } from '../utils/local-agent-registry'
+
+import type {
+  PublishAgentsErrorResponse,
+  PublishAgentsResponse,
+} from '@anvil/common/types/api/agents/publish'
+
+export interface PublishResult {
+  success: boolean
+  publisherId?: string
+  agents?: Array<{
+    id: string
+    version: string
+    displayName: string
+  }>
+  error?: string
+  details?: string
+  hint?: string
+}
+
+/**
+ * Publish agent templates to the backend
+ */
+async function publishAgentTemplates(
+  data: Record<string, any>[],
+  authToken: string,
+  allLocalAgentIds: string[],
+): Promise<PublishAgentsResponse & { statusCode?: number }> {
+  setApiClientAuthToken(authToken)
+  const apiClient = getApiClient()
+
+  try {
+    const response = await apiClient.publish(data, allLocalAgentIds)
+
+    if (!response.ok) {
+      // Try to use the full error data if available (includes details, hint, etc.)
+      const errorData = response.errorData as
+        | Partial<PublishAgentsErrorResponse>
+        | undefined
+      return {
+        success: false,
+        error: errorData?.error ?? response.error ?? 'Unknown error',
+        details: errorData?.details,
+        hint: errorData?.hint,
+        availablePublishers: errorData?.availablePublishers,
+        validationErrors: errorData?.validationErrors,
+        statusCode: response.status,
+      }
+    }
+
+    // Guard against empty/undefined response data
+    if (!response.data) {
+      return {
+        success: false,
+        error: 'Failed to parse server response - empty response body',
+        statusCode: response.status,
+      }
+    }
+
+    return {
+      ...response.data,
+      statusCode: response.status,
+    }
+  } catch (err: any) {
+    if (err instanceof TypeError && err.message.includes('fetch')) {
+      return {
+        success: false,
+        error: `Network error: Unable to connect to ${WEBSITE_URL}. Please check your internet connection and try again.`,
+      }
+    }
+
+    const body = err?.responseBody || err?.body || err
+    const error = body?.error || body?.message || 'Failed to publish'
+    const details = body?.details
+    const hint = body?.hint
+
+    return {
+      success: false,
+      error,
+      details,
+      hint,
+    }
+  }
+}
+
+/**
+ * Handle the publish command to upload agent templates to the backend
+ * @param agentIds The ids or display names of the agents to publish
+ * @returns PublishResult with success/error information
+ */
+export async function handlePublish(agentIds: string[]): Promise<PublishResult> {
+  const user = getUserCredentials()
+
+  if (!user) {
+    return {
+      success: false,
+      error: 'Not logged in',
+      hint: 'Please log in first using "login" command or web UI.',
+    }
+  }
+
+  const availableAgents = getLoadedAgentsData()?.agents || []
+
+  if (agentIds?.length === 0) {
+    return {
+      success: false,
+      error: 'No agents specified',
+      hint: 'Usage: publish <agent-id> [agent-id2] ...',
+    }
+  }
+
+  try {
+    const loadedDefinitions = loadAgentDefinitions()
+
+    if (loadedDefinitions.length === 0) {
+      return {
+        success: false,
+        error: 'No valid agent templates found in .agents directory.',
+      }
+    }
+
+    const matchingTemplates: Record<string, any> = {}
+
+    for (const agentId of agentIds) {
+      // Find the specific agent
+      const matchingTemplate = loadedDefinitions.find(
+        (template) =>
+          template.id === agentId ||
+          (template as { displayName?: string }).displayName === agentId,
+      )
+
+      if (!matchingTemplate) {
+        const availableList = availableAgents
+          .map((agent) =>
+            agent.displayName && agent.displayName !== agent.id
+              ? `${agent.displayName} (${agent.id})`
+              : agent.displayName || agent.id,
+          )
+          .join(', ')
+        return {
+          success: false,
+          error: `Agent "${agentId}" not found`,
+          details: `Available agents: ${availableList}`,
+        }
+      }
+
+      // Process the template for publishing
+      const processedTemplate = { ...matchingTemplate }
+
+      // Convert handleSteps function to string if present
+      if (typeof (matchingTemplate as any).handleSteps === 'function') {
+        ;(processedTemplate as any).handleSteps = (
+          matchingTemplate as any
+        ).handleSteps.toString()
+      }
+
+      matchingTemplates[matchingTemplate.id] = processedTemplate
+    }
+
+    // Get all local agent IDs so the server knows which agents exist locally
+    // (even if not being published) for validation purposes
+    const allLocalAgentIds = loadedDefinitions.map((template) => template.id)
+
+    const result = await publishAgentTemplates(
+      Object.values(matchingTemplates),
+      user.authToken!,
+      allLocalAgentIds,
+    )
+
+    if (result.success) {
+      return {
+        success: true,
+        publisherId: result.publisherId,
+        agents: result.agents ?? [],
+      }
+    }
+
+    // Build error result
+    let hint = result.hint
+    if (result.error?.includes('Publisher field required')) {
+      hint = 'Add a "publisher" field to your agent templates.'
+    } else if (result.error?.includes('Publisher not found or not accessible')) {
+      hint = `Check that the publisher ID is correct and you have access to it. Visit ${WEBSITE_URL}/publishers to manage publishers.`
+    }
+
+    return {
+      success: false,
+      error: result.error,
+      details: result.details,
+      hint,
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: 'Publish failed',
+      details: error instanceof Error ? error.message : String(error),
+    }
+  }
+}

package/src/commands/router-utils.ts

@@ -0,0 +1,80 @@
+import { SLASHLESS_COMMAND_IDS } from '../data/slash-commands'
+
+/**
+ * Check if the input is a slash command (starts with '/').
+ *
+ * @example
+ * isSlashCommand('/help') // => true
+ * isSlashCommand('help')  // => false
+ */
+export function isSlashCommand(input: string): boolean {
+  return input.trim().startsWith('/')
+}
+
+/**
+ * Parse the command name from user input.
+ * ONLY works for slash commands (input starting with '/').
+ * Returns empty string if the input is not a slash command.
+ *
+ * @example
+ * parseCommand('/help') // => 'help'
+ * parseCommand('/LOGOUT') // => 'logout'
+ * parseCommand('/usage stats') // => 'usage'
+ * parseCommand('help') // => '' (not a slash command)
+ * parseCommand('logout') // => '' (not a slash command)
+ */
+export function parseCommand(input: string): string {
+  const trimmed = input.trim()
+  if (!trimmed.startsWith('/')) {
+    return ''
+  }
+  const normalized = trimmed.slice(1)
+  const firstWord = normalized.split(/\s+/)[0] || ''
+  return firstWord.toLowerCase()
+}
+
+/**
+ * Result of parsing a command-like input.
+ */
+export type ParsedCommandInput = {
+  command: string
+  args: string
+  implicitCommand: boolean
+}
+
+/**
+ * Parse a command from user input.
+ * Supports:
+ * - Standard slash commands: "/command args"
+ * - Slashless exact commands: "init" (only if configured)
+ *
+ * Returns null when the input should be treated as a normal message.
+ *
+ * @example
+ * parseCommandInput('/help') // => { command: 'help', args: '', implicitCommand: false }
+ * parseCommandInput('/usage stats') // => { command: 'usage', args: 'stats', implicitCommand: false }
+ * parseCommandInput('init') // => { command: 'init', args: '', implicitCommand: true }
+ * parseCommandInput('init something') // => null
+ */
+export function parseCommandInput(input: string): ParsedCommandInput | null {
+  const trimmed = input.trim()
+  if (!trimmed) return null
+
+  if (trimmed.startsWith('/')) {
+    const command = parseCommand(trimmed)
+    if (!command) return null
+    const args = trimmed.slice(1 + command.length).trim()
+    return { command, args, implicitCommand: false }
+  }
+
+  if (/\s/.test(trimmed)) {
+    return null
+  }
+
+  const normalized = trimmed.toLowerCase()
+  if (!SLASHLESS_COMMAND_IDS.has(normalized)) {
+    return null
+  }
+
+  return { command: normalized, args: '', implicitCommand: true }
+}