yzcode-cli 1.0.1 → 1.0.3

package/outputStyles/loadOutputStylesDir.ts

@@ -0,0 +1,98 @@
+import memoize from 'lodash-es/memoize.js'
+import { basename } from 'path'
+import type { OutputStyleConfig } from '../constants/outputStyles.js'
+import { logForDebugging } from '../utils/debug.js'
+import { coerceDescriptionToString } from '../utils/frontmatterParser.js'
+import { logError } from '../utils/log.js'
+import {
+  extractDescriptionFromMarkdown,
+  loadMarkdownFilesForSubdir,
+} from '../utils/markdownConfigLoader.js'
+import { clearPluginOutputStyleCache } from '../utils/plugins/loadPluginOutputStyles.js'
+
+/**
+ * Loads markdown files from .claude/output-styles directories throughout the project
+ * and from ~/.claude/output-styles directory and converts them to output styles.
+ *
+ * Each filename becomes a style name, and the file content becomes the style prompt.
+ * The frontmatter provides name and description.
+ *
+ * Structure:
+ * - Project .claude/output-styles/*.md -> project styles
+ * - User ~/.claude/output-styles/*.md -> user styles (overridden by project styles)
+ *
+ * @param cwd Current working directory for project directory traversal
+ */
+export const getOutputStyleDirStyles = memoize(
+  async (cwd: string): Promise<OutputStyleConfig[]> => {
+    try {
+      const markdownFiles = await loadMarkdownFilesForSubdir(
+        'output-styles',
+        cwd,
+      )
+
+      const styles = markdownFiles
+        .map(({ filePath, frontmatter, content, source }) => {
+          try {
+            const fileName = basename(filePath)
+            const styleName = fileName.replace(/\.md$/, '')
+
+            // Get style configuration from frontmatter
+            const name = (frontmatter['name'] || styleName) as string
+            const description =
+              coerceDescriptionToString(
+                frontmatter['description'],
+                styleName,
+              ) ??
+              extractDescriptionFromMarkdown(
+                content,
+                `Custom ${styleName} output style`,
+              )
+
+            // Parse keep-coding-instructions flag (supports both boolean and string values)
+            const keepCodingInstructionsRaw =
+              frontmatter['keep-coding-instructions']
+            const keepCodingInstructions =
+              keepCodingInstructionsRaw === true ||
+              keepCodingInstructionsRaw === 'true'
+                ? true
+                : keepCodingInstructionsRaw === false ||
+                    keepCodingInstructionsRaw === 'false'
+                  ? false
+                  : undefined
+
+            // Warn if force-for-plugin is set on non-plugin output style
+            if (frontmatter['force-for-plugin'] !== undefined) {
+              logForDebugging(
+                `Output style "${name}" has force-for-plugin set, but this option only applies to plugin output styles. Ignoring.`,
+                { level: 'warn' },
+              )
+            }
+
+            return {
+              name,
+              description,
+              prompt: content.trim(),
+              source,
+              keepCodingInstructions,
+            }
+          } catch (error) {
+            logError(error)
+            return null
+          }
+        })
+        .filter(style => style !== null)
+
+      return styles
+    } catch (error) {
+      logError(error)
+      return []
+    }
+  },
+)
+
+export function clearOutputStyleCaches(): void {
+  getOutputStyleDirStyles.cache?.clear?.()
+  loadMarkdownFilesForSubdir.cache?.clear?.()
+  clearPluginOutputStyleCache()
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yzcode-cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "YZcode - AI编程助手命令行工具",
   "type": "module",
   "bin": {
@@ -8,9 +8,9 @@
     "yzcode-config": "./bin/yzcode-config.js"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.88",
-    "@anthropic-ai/mcpb": "^2.1.2",
-    "@anthropic-ai/sdk": "^0.80.0",
+    "@anthropic-ai/claude-agent-sdk": "0.2.88",
+    "@anthropic-ai/mcpb": "2.1.2",
+    "@anthropic-ai/sdk": "0.80.0",
     "@aws-sdk/client-bedrock-runtime": "^3.709.0",
     "@commander-js/extra-typings": "^12.1.0",
     "@growthbook/growthbook": "^0.33.0",
@@ -91,6 +91,23 @@
     "*.ts",
     "*.tsx",
     "bin",
-    "node_modules"
+    "bootstrap",
+    "assistant",
+    "buddy",
+    "bridge",
+    "coordinator",
+    "memdir",
+    "migrations",
+    "native-ts",
+    "outputStyles",
+    "plugins",
+    "schemas",
+    "screens",
+    "server",
+    "skills",
+    "tasks",
+    "upstreamproxy",
+    "vim",
+    "voice"
   ]
 }

package/plugins/builtinPlugins.ts

@@ -0,0 +1,159 @@
+/**
+ * Built-in Plugin Registry
+ *
+ * Manages built-in plugins that ship with the CLI and can be enabled/disabled
+ * by users via the /plugin UI.
+ *
+ * Built-in plugins differ from bundled skills (src/skills/bundled/) in that:
+ * - They appear in the /plugin UI under a "Built-in" section
+ * - Users can enable/disable them (persisted to user settings)
+ * - They can provide multiple components (skills, hooks, MCP servers)
+ *
+ * Plugin IDs use the format `{name}@builtin` to distinguish them from
+ * marketplace plugins (`{name}@{marketplace}`).
+ */
+
+import type { Command } from '../commands.js'
+import type { BundledSkillDefinition } from '../skills/bundledSkills.js'
+import type { BuiltinPluginDefinition, LoadedPlugin } from '../types/plugin.js'
+import { getSettings_DEPRECATED } from '../utils/settings/settings.js'
+
+const BUILTIN_PLUGINS: Map<string, BuiltinPluginDefinition> = new Map()
+
+export const BUILTIN_MARKETPLACE_NAME = 'builtin'
+
+/**
+ * Register a built-in plugin. Call this from initBuiltinPlugins() at startup.
+ */
+export function registerBuiltinPlugin(
+  definition: BuiltinPluginDefinition,
+): void {
+  BUILTIN_PLUGINS.set(definition.name, definition)
+}
+
+/**
+ * Check if a plugin ID represents a built-in plugin (ends with @builtin).
+ */
+export function isBuiltinPluginId(pluginId: string): boolean {
+  return pluginId.endsWith(`@${BUILTIN_MARKETPLACE_NAME}`)
+}
+
+/**
+ * Get a specific built-in plugin definition by name.
+ * Useful for the /plugin UI to show the skills/hooks/MCP list without
+ * a marketplace lookup.
+ */
+export function getBuiltinPluginDefinition(
+  name: string,
+): BuiltinPluginDefinition | undefined {
+  return BUILTIN_PLUGINS.get(name)
+}
+
+/**
+ * Get all registered built-in plugins as LoadedPlugin objects, split into
+ * enabled/disabled based on user settings (with defaultEnabled as fallback).
+ * Plugins whose isAvailable() returns false are omitted entirely.
+ */
+export function getBuiltinPlugins(): {
+  enabled: LoadedPlugin[]
+  disabled: LoadedPlugin[]
+} {
+  const settings = getSettings_DEPRECATED()
+  const enabled: LoadedPlugin[] = []
+  const disabled: LoadedPlugin[] = []
+
+  for (const [name, definition] of BUILTIN_PLUGINS) {
+    if (definition.isAvailable && !definition.isAvailable()) {
+      continue
+    }
+
+    const pluginId = `${name}@${BUILTIN_MARKETPLACE_NAME}`
+    const userSetting = settings?.enabledPlugins?.[pluginId]
+    // Enabled state: user preference > plugin default > true
+    const isEnabled =
+      userSetting !== undefined
+        ? userSetting === true
+        : (definition.defaultEnabled ?? true)
+
+    const plugin: LoadedPlugin = {
+      name,
+      manifest: {
+        name,
+        description: definition.description,
+        version: definition.version,
+      },
+      path: BUILTIN_MARKETPLACE_NAME, // sentinel — no filesystem path
+      source: pluginId,
+      repository: pluginId,
+      enabled: isEnabled,
+      isBuiltin: true,
+      hooksConfig: definition.hooks,
+      mcpServers: definition.mcpServers,
+    }
+
+    if (isEnabled) {
+      enabled.push(plugin)
+    } else {
+      disabled.push(plugin)
+    }
+  }
+
+  return { enabled, disabled }
+}
+
+/**
+ * Get skills from enabled built-in plugins as Command objects.
+ * Skills from disabled plugins are not returned.
+ */
+export function getBuiltinPluginSkillCommands(): Command[] {
+  const { enabled } = getBuiltinPlugins()
+  const commands: Command[] = []
+
+  for (const plugin of enabled) {
+    const definition = BUILTIN_PLUGINS.get(plugin.name)
+    if (!definition?.skills) continue
+    for (const skill of definition.skills) {
+      commands.push(skillDefinitionToCommand(skill))
+    }
+  }
+
+  return commands
+}
+
+/**
+ * Clear built-in plugins registry (for testing).
+ */
+export function clearBuiltinPlugins(): void {
+  BUILTIN_PLUGINS.clear()
+}
+
+// --
+
+function skillDefinitionToCommand(definition: BundledSkillDefinition): Command {
+  return {
+    type: 'prompt',
+    name: definition.name,
+    description: definition.description,
+    hasUserSpecifiedDescription: true,
+    allowedTools: definition.allowedTools ?? [],
+    argumentHint: definition.argumentHint,
+    whenToUse: definition.whenToUse,
+    model: definition.model,
+    disableModelInvocation: definition.disableModelInvocation ?? false,
+    userInvocable: definition.userInvocable ?? true,
+    contentLength: 0,
+    // 'bundled' not 'builtin' — 'builtin' in Command.source means hardcoded
+    // slash commands (/help, /clear). Using 'bundled' keeps these skills in
+    // the Skill tool's listing, analytics name logging, and prompt-truncation
+    // exemption. The user-toggleable aspect is tracked on LoadedPlugin.isBuiltin.
+    source: 'bundled',
+    loadedFrom: 'bundled',
+    hooks: definition.hooks,
+    context: definition.context,
+    agent: definition.agent,
+    isEnabled: definition.isEnabled ?? (() => true),
+    isHidden: !(definition.userInvocable ?? true),
+    progressMessage: 'running',
+    getPromptForCommand: definition.getPromptForCommand,
+  }
+}

package/plugins/bundled/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Built-in Plugin Initialization
+ *
+ * Initializes built-in plugins that ship with the CLI and appear in the
+ * /plugin UI for users to enable/disable.
+ *
+ * Not all bundled features should be built-in plugins — use this for
+ * features that users should be able to explicitly enable/disable. For
+ * features with complex setup or automatic-enabling logic (e.g.
+ * claude-in-chrome), use src/skills/bundled/ instead.
+ *
+ * To add a new built-in plugin:
+ * 1. Import registerBuiltinPlugin from '../builtinPlugins.js'
+ * 2. Call registerBuiltinPlugin() with the plugin definition here
+ */
+
+/**
+ * Initialize built-in plugins. Called during CLI startup.
+ */
+export function initBuiltinPlugins(): void {
+  // No built-in plugins registered yet — this is the scaffolding for
+  // migrating bundled skills that should be user-toggleable.
+}

package/schemas/hooks.ts

@@ -0,0 +1,222 @@
+/**
+ * Hook Zod schemas extracted to break import cycles.
+ *
+ * This file contains hook-related schema definitions that were originally
+ * in src/utils/settings/types.ts. By extracting them here, we break the
+ * circular dependency between settings/types.ts and plugins/schemas.ts.
+ *
+ * Both files now import from this shared location instead of each other.
+ */
+
+import { HOOK_EVENTS, type HookEvent } from 'src/entrypoints/agentSdkTypes.js'
+import { z } from 'zod/v4'
+import { lazySchema } from '../utils/lazySchema.js'
+import { SHELL_TYPES } from '../utils/shell/shellProvider.js'
+
+// Shared schema for the `if` condition field.
+// Uses permission rule syntax (e.g., "Bash(git *)", "Read(*.ts)") to filter hooks
+// before spawning. Evaluated against the hook input's tool_name and tool_input.
+const IfConditionSchema = lazySchema(() =>
+  z
+    .string()
+    .optional()
+    .describe(
+      'Permission rule syntax to filter when this hook runs (e.g., "Bash(git *)"). ' +
+        'Only runs if the tool call matches the pattern. Avoids spawning hooks for non-matching commands.',
+    ),
+)
+
+// Internal factory for individual hook schemas (shared between exported
+// discriminated union members and the HookCommandSchema factory)
+function buildHookSchemas() {
+  const BashCommandHookSchema = z.object({
+    type: z.literal('command').describe('Shell command hook type'),
+    command: z.string().describe('Shell command to execute'),
+    if: IfConditionSchema(),
+    shell: z
+      .enum(SHELL_TYPES)
+      .optional()
+      .describe(
+        "Shell interpreter. 'bash' uses your $SHELL (bash/zsh/sh); 'powershell' uses pwsh. Defaults to bash.",
+      ),
+    timeout: z
+      .number()
+      .positive()
+      .optional()
+      .describe('Timeout in seconds for this specific command'),
+    statusMessage: z
+      .string()
+      .optional()
+      .describe('Custom status message to display in spinner while hook runs'),
+    once: z
+      .boolean()
+      .optional()
+      .describe('If true, hook runs once and is removed after execution'),
+    async: z
+      .boolean()
+      .optional()
+      .describe('If true, hook runs in background without blocking'),
+    asyncRewake: z
+      .boolean()
+      .optional()
+      .describe(
+        'If true, hook runs in background and wakes the model on exit code 2 (blocking error). Implies async.',
+      ),
+  })
+
+  const PromptHookSchema = z.object({
+    type: z.literal('prompt').describe('LLM prompt hook type'),
+    prompt: z
+      .string()
+      .describe(
+        'Prompt to evaluate with LLM. Use $ARGUMENTS placeholder for hook input JSON.',
+      ),
+    if: IfConditionSchema(),
+    timeout: z
+      .number()
+      .positive()
+      .optional()
+      .describe('Timeout in seconds for this specific prompt evaluation'),
+    // @[MODEL LAUNCH]: Update the example model ID in the .describe() strings below (prompt + agent hooks).
+    model: z
+      .string()
+      .optional()
+      .describe(
+        'Model to use for this prompt hook (e.g., "claude-sonnet-4-6"). If not specified, uses the default small fast model.',
+      ),
+    statusMessage: z
+      .string()
+      .optional()
+      .describe('Custom status message to display in spinner while hook runs'),
+    once: z
+      .boolean()
+      .optional()
+      .describe('If true, hook runs once and is removed after execution'),
+  })
+
+  const HttpHookSchema = z.object({
+    type: z.literal('http').describe('HTTP hook type'),
+    url: z.string().url().describe('URL to POST the hook input JSON to'),
+    if: IfConditionSchema(),
+    timeout: z
+      .number()
+      .positive()
+      .optional()
+      .describe('Timeout in seconds for this specific request'),
+    headers: z
+      .record(z.string(), z.string())
+      .optional()
+      .describe(
+        'Additional headers to include in the request. Values may reference environment variables using $VAR_NAME or ${VAR_NAME} syntax (e.g., "Authorization": "Bearer $MY_TOKEN"). Only variables listed in allowedEnvVars will be interpolated.',
+      ),
+    allowedEnvVars: z
+      .array(z.string())
+      .optional()
+      .describe(
+        'Explicit list of environment variable names that may be interpolated in header values. Only variables listed here will be resolved; all other $VAR references are left as empty strings. Required for env var interpolation to work.',
+      ),
+    statusMessage: z
+      .string()
+      .optional()
+      .describe('Custom status message to display in spinner while hook runs'),
+    once: z
+      .boolean()
+      .optional()
+      .describe('If true, hook runs once and is removed after execution'),
+  })
+
+  const AgentHookSchema = z.object({
+    type: z.literal('agent').describe('Agentic verifier hook type'),
+    // DO NOT add .transform() here. This schema is used by parseSettingsFile,
+    // and updateSettingsForSource round-trips the parsed result through
+    // JSON.stringify — a transformed function value is silently dropped,
+    // deleting the user's prompt from settings.json (gh-24920, CC-79). The
+    // transform (from #10594) wrapped the string in `(_msgs) => prompt`
+    // for a programmatic-construction use case in ExitPlanModeV2Tool that
+    // has since been refactored into VerifyPlanExecutionTool, which no
+    // longer constructs AgentHook objects at all.
+    prompt: z
+      .string()
+      .describe(
+        'Prompt describing what to verify (e.g. "Verify that unit tests ran and passed."). Use $ARGUMENTS placeholder for hook input JSON.',
+      ),
+    if: IfConditionSchema(),
+    timeout: z
+      .number()
+      .positive()
+      .optional()
+      .describe('Timeout in seconds for agent execution (default 60)'),
+    model: z
+      .string()
+      .optional()
+      .describe(
+        'Model to use for this agent hook (e.g., "claude-sonnet-4-6"). If not specified, uses Haiku.',
+      ),
+    statusMessage: z
+      .string()
+      .optional()
+      .describe('Custom status message to display in spinner while hook runs'),
+    once: z
+      .boolean()
+      .optional()
+      .describe('If true, hook runs once and is removed after execution'),
+  })
+
+  return {
+    BashCommandHookSchema,
+    PromptHookSchema,
+    HttpHookSchema,
+    AgentHookSchema,
+  }
+}
+
+/**
+ * Schema for hook command (excludes function hooks - they can't be persisted)
+ */
+export const HookCommandSchema = lazySchema(() => {
+  const {
+    BashCommandHookSchema,
+    PromptHookSchema,
+    AgentHookSchema,
+    HttpHookSchema,
+  } = buildHookSchemas()
+  return z.discriminatedUnion('type', [
+    BashCommandHookSchema,
+    PromptHookSchema,
+    AgentHookSchema,
+    HttpHookSchema,
+  ])
+})
+
+/**
+ * Schema for matcher configuration with multiple hooks
+ */
+export const HookMatcherSchema = lazySchema(() =>
+  z.object({
+    matcher: z
+      .string()
+      .optional()
+      .describe('String pattern to match (e.g. tool names like "Write")'), // String (e.g. Write) to match values related to the hook event, e.g. tool names
+    hooks: z
+      .array(HookCommandSchema())
+      .describe('List of hooks to execute when the matcher matches'),
+  }),
+)
+
+/**
+ * Schema for hooks configuration
+ * The key is the hook event. The value is an array of matcher configurations.
+ * Uses partialRecord since not all hook events need to be defined.
+ */
+export const HooksSchema = lazySchema(() =>
+  z.partialRecord(z.enum(HOOK_EVENTS), z.array(HookMatcherSchema())),
+)
+
+// Inferred types from schemas
+export type HookCommand = z.infer<ReturnType<typeof HookCommandSchema>>
+export type BashCommandHook = Extract<HookCommand, { type: 'command' }>
+export type PromptHook = Extract<HookCommand, { type: 'prompt' }>
+export type AgentHook = Extract<HookCommand, { type: 'agent' }>
+export type HttpHook = Extract<HookCommand, { type: 'http' }>
+export type HookMatcher = z.infer<ReturnType<typeof HookMatcherSchema>>
+export type HooksSettings = Partial<Record<HookEvent, HookMatcher[]>>