veryfront 0.1.111 → 0.1.113

package/src/cli/help/main-help.ts

@@ -1,4 +1,5 @@
 import { COMMANDS } from "./command-definitions.js";
+import type { CommandCategory, CommandHelp } from "./types.js";
 import {
   calculateMaxLength,
   formatCommandList,
@@ -9,6 +10,34 @@ import {
 } from "./formatters.js";
 import { bold, dim } from "../ui/colors.js";
 
+const CATEGORY_LABELS: Record<CommandCategory, string> = {
+  development: "Development",
+  deploy: "Deploy & Sync",
+  project: "Project",
+  files: "Files & Data",
+  ai: "AI & Automation",
+  auth: "Auth",
+};
+
+const CATEGORY_ORDER: CommandCategory[] = [
+  "development",
+  "deploy",
+  "project",
+  "files",
+  "ai",
+  "auth",
+];
+
+function groupByCategory(commands: CommandHelp[]): Map<CommandCategory, CommandHelp[]> {
+  const groups = new Map<CommandCategory, CommandHelp[]>();
+  for (const cmd of commands) {
+    const group = groups.get(cmd.category) ?? [];
+    group.push(cmd);
+    groups.set(cmd.category, group);
+  }
+  return groups;
+}
+
 export function showMainHelp(): void {
   console.log(formatHeader());
   console.log();
@@ -17,13 +46,19 @@ export function showMainHelp(): void {
 
   const commands = Object.values(COMMANDS);
   const maxLength = calculateMaxLength(commands.map((c) => ({ length: c.name.length })));
+  const grouped = groupByCategory(commands);
+
+  for (const category of CATEGORY_ORDER) {
+    const cmds = grouped.get(category);
+    if (!cmds || cmds.length === 0) continue;
 
-  console.log(`  ${formatSectionHeader("Commands")}`);
-  for (const line of formatCommandList(commands, maxLength)) {
-    console.log(line);
+    console.log(`  ${formatSectionHeader(CATEGORY_LABELS[category])}`);
+    for (const line of formatCommandList(cmds, maxLength)) {
+      console.log(line);
+    }
+    console.log();
   }
 
-  console.log();
   console.log(`  ${formatSectionHeader("Global Options")}`);
   console.log(
     `    ${formatCommandName("-h, --help", maxLength)} ${formatDescription("Show help")}`,
@@ -31,6 +66,14 @@ export function showMainHelp(): void {
   console.log(
     `    ${formatCommandName("-v, --version", maxLength)} ${formatDescription("Show version")}`,
   );
+  console.log(
+    `    ${formatCommandName("--json", maxLength)} ${formatDescription("Output as JSON")}`,
+  );
+  console.log(
+    `    ${formatCommandName("--yes", maxLength)} ${
+      formatDescription("Skip confirmation prompts")
+    }`,
+  );
 
   console.log();
   console.log(`  ${formatSectionHeader("Quick Start")}`);
@@ -42,7 +85,7 @@ export function showMainHelp(): void {
   console.log(`  ${formatSectionHeader("Coding Agents (MCP)")}`);
   console.log(`    ${dim("HTTP:")}   MCP auto-starts on port 9999 with dev server`);
   console.log(`    ${dim("stdio:")}  veryfront mcp`);
-  console.log(`    ${dim("Tools:")}  vf_list_templates, vf_create_project, vf_scaffold, ...`);
+  console.log(`    ${dim("Schema:")} veryfront schema --json`);
 
   console.log();
   console.log(`  ${formatSectionHeader("Learn More")}`);

package/src/cli/help/types.ts

@@ -1,3 +1,11 @@
+export type CommandCategory =
+  | "development"
+  | "deploy"
+  | "project"
+  | "files"
+  | "ai"
+  | "auth";
+
 export interface CommandOption {
   flag: string;
   description: string;
@@ -6,6 +14,7 @@ export interface CommandOption {
 
 export interface CommandHelp {
   name: string;
+  category: CommandCategory;
   description: string;
   usage: string;
   options?: CommandOption[];

package/src/cli/mcp/advanced-tools.ts

@@ -23,8 +23,12 @@ import {
 } from "./tools/project-tools.js";
 import { vfGetConventions, vfScaffold } from "./tools/scaffold-tools.js";
 import { vfGetSkillReference, vfGetSkills } from "./tools/skill-tools.js";
+import { cicdTools } from "./tools/cicd-tools.js";
+import { introspectionTools } from "./tools/introspection-tools.js";
 
 export const advancedTools: MCPTool[] = [
+  ...cicdTools,
+  ...introspectionTools,
   vfGetSkills,
   vfGetSkillReference,
   vfListLocalProjects,

package/src/cli/mcp/server.ts

@@ -262,6 +262,30 @@ export class MCPDevServer {
           description: "File-based issues, tasks, and plans",
           mimeType: "application/json",
         },
+        {
+          uri: "veryfront://schema",
+          name: "CLI Schema",
+          description: "Full CLI command schema for agent discovery",
+          mimeType: "application/json",
+        },
+        {
+          uri: "veryfront://agents-md",
+          name: "Root AGENTS.md",
+          description: "Agent onboarding documentation",
+          mimeType: "text/markdown",
+        },
+        {
+          uri: "veryfront://config",
+          name: "Project Config",
+          description: "Resolved project configuration",
+          mimeType: "application/json",
+        },
+        {
+          uri: "veryfront://skills",
+          name: "Available Skills",
+          description: "List of all available agent skills",
+          mimeType: "application/json",
+        },
       ],
     };
   }
@@ -316,6 +340,54 @@ export class MCPDevServer {
           };
         }
 
+        if (uri === "veryfront://schema") {
+          const { generateSchema } = await import("../commands/schema/command.js");
+          return {
+            contents: [{
+              uri,
+              mimeType: "application/json",
+              text: JSON.stringify(generateSchema()),
+            }],
+          };
+        }
+
+        if (uri === "veryfront://agents-md") {
+          const content = await readTextFile("AGENTS.md").catch(() => "AGENTS.md not found");
+          return {
+            contents: [{ uri, mimeType: "text/markdown", text: content }],
+          };
+        }
+
+        if (uri === "veryfront://config") {
+          const { getEnvironmentConfig } = await import("../../src/config/index.js");
+          const config = getEnvironmentConfig();
+          return {
+            contents: [{
+              uri,
+              mimeType: "application/json",
+              text: JSON.stringify(config, null, 2),
+            }],
+          };
+        }
+
+        if (uri === "veryfront://skills") {
+          const { listCoreSkills } = await import("../skills/loader.js");
+          const skills = await listCoreSkills();
+          const data = skills.map((s) => ({
+            name: s.manifest.name,
+            version: s.manifest.version,
+            description: s.manifest.description,
+            requires: s.manifest.requires,
+          }));
+          return {
+            contents: [{
+              uri,
+              mimeType: "application/json",
+              text: JSON.stringify(data, null, 2),
+            }],
+          };
+        }
+
         if (!uri.startsWith("issues://")) throw new Error(`Unknown resource: ${uri}`);
 
         const manager = createIssuesManager(cwd());

package/src/cli/mcp/standalone.ts

@@ -17,6 +17,7 @@ import {
   type JSONRPCResponse,
   parseError,
   PromptsGetParamsSchema,
+  ResourcesReadParamsSchema,
   successResponse,
   ToolsCallParamsSchema,
 } from "./jsonrpc.js";
@@ -80,7 +81,7 @@ export class StandaloneMCPServer {
       case "initialize":
         return Promise.resolve({
           protocolVersion: "2024-11-05",
-          capabilities: { tools: {}, prompts: {} },
+          capabilities: { tools: {}, resources: {}, prompts: {} },
           serverInfo: { name: "veryfront-mcp", version: "1.0.0" },
         });
       case "notifications/initialized":
@@ -95,6 +96,10 @@ export class StandaloneMCPServer {
         });
       case "tools/call":
         return this.handleToolsCall(params);
+      case "resources/list":
+        return Promise.resolve(this.handleResourcesList());
+      case "resources/read":
+        return this.handleResourcesRead(params);
       case "prompts/list":
         return Promise.resolve(this.handlePromptsList());
       case "prompts/get":
@@ -114,6 +119,76 @@ export class StandaloneMCPServer {
     return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
   }
 
+  private handleResourcesList(): unknown {
+    return {
+      resources: [
+        {
+          uri: "veryfront://schema",
+          name: "CLI Schema",
+          description: "Full CLI command schema for agent discovery",
+          mimeType: "application/json",
+        },
+        {
+          uri: "veryfront://agents-md",
+          name: "Root AGENTS.md",
+          description: "Agent onboarding documentation",
+          mimeType: "text/markdown",
+        },
+        {
+          uri: "veryfront://skills",
+          name: "Available Skills",
+          description: "List of all available agent skills",
+          mimeType: "application/json",
+        },
+      ],
+    };
+  }
+
+  private async handleResourcesRead(params: unknown): Promise<unknown> {
+    const { uri } = ResourcesReadParamsSchema.parse(params);
+
+    if (uri === "veryfront://schema") {
+      const { generateSchema } = await import("../commands/schema/command.js");
+      return {
+        contents: [{
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(generateSchema(), null, 2),
+        }],
+      };
+    }
+
+    if (uri === "veryfront://agents-md") {
+      try {
+        const agentsPath = new URL("../../AGENTS.md", import.meta.url).pathname;
+        const content = await readTextFile(agentsPath);
+        return { contents: [{ uri, mimeType: "text/markdown", text: content }] };
+      } catch {
+        return { contents: [{ uri, mimeType: "text/markdown", text: "AGENTS.md not found" }] };
+      }
+    }
+
+    if (uri === "veryfront://skills") {
+      const { listCoreSkills } = await import("../skills/loader.js");
+      const skills = await listCoreSkills();
+      const data = skills.map((s) => ({
+        name: s.manifest.name,
+        version: s.manifest.version,
+        description: s.manifest.description,
+        requires: s.manifest.requires,
+      }));
+      return {
+        contents: [{
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(data, null, 2),
+        }],
+      };
+    }
+
+    throw new Error(`Unknown resource: ${uri}`);
+  }
+
   private handlePromptsList(): unknown {
     return {
       prompts: [
@@ -160,6 +235,63 @@ export class StandaloneMCPServer {
     const client = this.client;
 
     return [
+      {
+        name: "vf_get_schema",
+        description:
+          "Get the CLI command schema for discovering available commands, arguments, and flags.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            command: {
+              type: "string",
+              description: "Get schema for a specific command",
+            },
+            category: {
+              type: "string",
+              description: "Filter by category",
+            },
+          },
+        },
+        async execute(args) {
+          const { generateCommandSchema, generateSchema } = await import(
+            "../commands/schema/command.js"
+          );
+          if (args.command) {
+            return generateCommandSchema(args.command as string) ??
+              { error: `Unknown command: ${args.command}` };
+          }
+          return generateSchema(
+            args.category as
+              | "development"
+              | "deploy"
+              | "project"
+              | "files"
+              | "ai"
+              | "auth"
+              | undefined,
+          );
+        },
+      },
+      {
+        name: "vf_get_project_info",
+        description: "Get project metadata including project slug, version, and environment.",
+        inputSchema: { type: "object", properties: {} },
+        async execute() {
+          const { VERSION } = await import("../utils/index.js");
+          try {
+            const { getEnvironmentConfig } = await import("../../src/config/index.js");
+            const config = getEnvironmentConfig();
+            return {
+              version: VERSION,
+              projectSlug: config.projectSlug ?? null,
+              nodeEnv: config.nodeEnv,
+              veryfrontEnv: config.veryfrontEnv,
+            };
+          } catch {
+            return { version: VERSION };
+          }
+        },
+      },
       {
         name: "vf_get_errors",
         description:

package/src/cli/mcp/tools/cicd-tools.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import type { MCPTool } from "../../../src/mcp/index.js";
+
+const getPipelineStatusInput = z.object({
+  projectSlug: z.string().describe("Project slug"),
+  environment: z.string().optional().default("production").describe("Target environment"),
+});
+
+const vfGetPipelineStatus: MCPTool = {
+  name: "vf_get_pipeline_status",
+  description: "Get the current build/deploy pipeline state for a project environment.",
+  inputSchema: getPipelineStatusInput,
+  execute: async (input: { projectSlug: string; environment: string }) => {
+    return {
+      status: "not_implemented",
+      message: "CI/CD pipeline API not yet available. This tool requires backend support.",
+      projectSlug: input.projectSlug,
+      environment: input.environment,
+    };
+  },
+};
+
+const getDeployHistoryInput = z.object({
+  projectSlug: z.string().describe("Project slug"),
+  limit: z.number().optional().default(10).describe("Number of recent deployments to return"),
+});
+
+const vfGetDeployHistory: MCPTool = {
+  name: "vf_get_deploy_history",
+  description: "List recent deployments with status, version, URL, and timestamp.",
+  inputSchema: getDeployHistoryInput,
+  execute: async (input: { projectSlug: string; limit: number }) => {
+    return {
+      status: "not_implemented",
+      message: "Deploy history API not yet available.",
+      projectSlug: input.projectSlug,
+    };
+  },
+};
+
+const getBuildLogsInput = z.object({
+  projectSlug: z.string().describe("Project slug"),
+  deployId: z.string().optional().describe("Specific deployment ID (latest if omitted)"),
+});
+
+const vfGetBuildLogs: MCPTool = {
+  name: "vf_get_build_logs",
+  description: "Get build logs from an active or recent build/deployment.",
+  inputSchema: getBuildLogsInput,
+  execute: async (input: { projectSlug: string; deployId?: string }) => {
+    return {
+      status: "not_implemented",
+      message: "Build logs API not yet available.",
+      projectSlug: input.projectSlug,
+    };
+  },
+};
+
+const triggerDeployInput = z.object({
+  projectSlug: z.string().describe("Project slug"),
+  environment: z.string().optional().default("production").describe("Target environment"),
+  branch: z.string().optional().default("main").describe("Branch to deploy"),
+});
+
+const vfTriggerDeploy: MCPTool = {
+  name: "vf_trigger_deploy",
+  description:
+    "Trigger a deployment to an environment. Returns a deployment ID for status tracking.",
+  inputSchema: triggerDeployInput,
+  execute: async (input: { projectSlug: string; environment: string; branch: string }) => {
+    return {
+      status: "not_implemented",
+      message: "Deploy trigger API not yet available.",
+      projectSlug: input.projectSlug,
+      environment: input.environment,
+      branch: input.branch,
+    };
+  },
+};
+
+export const cicdTools: MCPTool[] = [
+  vfGetPipelineStatus,
+  vfGetDeployHistory,
+  vfGetBuildLogs,
+  vfTriggerDeploy,
+];

package/src/cli/mcp/tools/introspection-tools.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import type { MCPTool } from "../../../src/mcp/index.js";
+import { generateCommandSchema, generateSchema } from "../../commands/schema/command.js";
+import type { CommandCategory } from "../../help/types.js";
+import { VERSION } from "../../utils/index.js";
+
+const getSchemaInput = z.object({
+  command: z.string().optional().describe("Get schema for a specific command"),
+  category: z.string().optional().describe("Filter by category"),
+});
+
+const vfGetSchema: MCPTool = {
+  name: "vf_get_schema",
+  description:
+    "Get the CLI command schema for discovering available commands, arguments, and flags.",
+  inputSchema: getSchemaInput,
+  execute: async (input: { command?: string; category?: string }) => {
+    if (input.command) {
+      return generateCommandSchema(input.command) ?? { error: `Unknown command: ${input.command}` };
+    }
+    return generateSchema(input.category as CommandCategory | undefined);
+  },
+};
+
+const getProjectInfoInput = z.object({});
+
+const vfGetProjectInfo: MCPTool = {
+  name: "vf_get_project_info",
+  description: "Get project metadata including project slug, version, and environment.",
+  inputSchema: getProjectInfoInput,
+  execute: async () => {
+    const { getEnvironmentConfig } = await import("../../../src/config/index.js");
+    const config = getEnvironmentConfig();
+    return {
+      version: VERSION,
+      projectSlug: config.projectSlug ?? null,
+      nodeEnv: config.nodeEnv,
+      veryfrontEnv: config.veryfrontEnv,
+    };
+  },
+};
+
+export const introspectionTools: MCPTool[] = [
+  vfGetSchema,
+  vfGetProjectInfo,
+];

package/src/cli/router.ts

@@ -34,11 +34,18 @@ import { handleUpCommand } from "./commands/up/index.js";
 import { handleTaskCommand } from "./commands/task/handler.js";
 import { handleWorkflowCommand } from "./commands/workflow/handler.js";
 import { handleWorkerCommand } from "./commands/worker/handler.js";
+import { handleSchemaCommand } from "./commands/schema/handler.js";
+import { handleTestCommand } from "./commands/test/handler.js";
+import { handleLintCommand } from "./commands/lint/handler.js";
+import { handleSkillsCommand } from "./commands/skills/handler.js";
+import { handleCompletionsCommand } from "./commands/completions/handler.js";
 import { login, logout, whoami } from "./auth/index.js";
 import { parseLoginMethod } from "./auth/utils.js";
 import { showCommandHelp, showMainHelp } from "./help/index.js";
 import { setColorOverride } from "./ui/colors.js";
 import { exitProcess, setQuietMode, setVerboseMode } from "./utils/index.js";
+import { setJsonMode, setOutputPath } from "./shared/json-output.js";
+import { detectCI, setNonInteractive } from "./shared/interactive.js";
 import type { ParsedArgs } from "./shared/types.js";
 
 /**
@@ -86,6 +93,11 @@ const commands: Record<string, (args: ParsedArgs) => Promise<void>> = {
   "task": handleTaskCommand,
   "workflow": handleWorkflowCommand,
   "worker": handleWorkerCommand,
+  "schema": handleSchemaCommand,
+  "test": handleTestCommand,
+  "lint": handleLintCommand,
+  "skills": handleSkillsCommand,
+  "completions": handleCompletionsCommand,
 };
 
 /**
@@ -112,6 +124,12 @@ export async function routeCommand(args: ParsedArgs): Promise<void> {
   if (args.verbose) setVerboseMode(true);
   else if (args.quiet || args.q) setQuietMode(true);
 
+  if (args.json || args.j) setJsonMode(true);
+  if (typeof args.output === "string") setOutputPath(args.output);
+  else if (typeof args.o === "string") setOutputPath(args.o as string);
+
+  if (args.yes || args.y || detectCI()) setNonInteractive(true);
+
   if (args.version || args.v) {
     cliLogger.info(`Veryfront CLI v${VERSION}`);
     exitProcess(0);
@@ -136,8 +154,21 @@ export async function routeCommand(args: ParsedArgs): Promise<void> {
     const handler = command ? commands[command] : undefined;
 
     if (command && !handler) {
+      const { suggestCommand } = await import("./shared/suggest.js");
+      const { COMMANDS } = await import("./help/command-definitions.js");
+      // Use canonical command names from help registry (excludes aliases like "g", "preview")
+      const canonicalNames = Object.keys(COMMANDS);
+      const suggestions = suggestCommand(command, canonicalNames);
       cliLogger.error(`Unknown command: ${command}\n`);
-      showHelp();
+      if (suggestions.length > 0) {
+        cliLogger.info(`  Did you mean?`);
+        for (const s of suggestions) {
+          const desc = COMMANDS[s]?.description ?? "";
+          cliLogger.info(`    ${s}    ${desc}`);
+        }
+      } else {
+        showHelp();
+      }
       exitProcess(1);
       return;
     }

package/src/cli/shared/args.ts

@@ -160,6 +160,7 @@ export const CommonArgs = {
   into: { keys: ["into"], type: "string" },
   release: { keys: ["release"], type: "string" },
   output: { keys: ["output", "o"], type: "string" },
+  json: { keys: ["json", "j"], type: "boolean" },
 } satisfies Record<string, ArgSpec>;
 
 // ── Raw CLI argument parsing ────────────────────────────────────────────
@@ -257,6 +258,7 @@ export function parseCliArgs(args: string[]): ParsedArgs {
       s: "strict",
       t: "template",
       j: "json",
+      y: "yes",
       w: "with",
       m: "mode",
     },

package/src/cli/shared/interactive.ts

@@ -0,0 +1,33 @@
+/**
+ * Interactive mode control for CLI
+ *
+ * Controls whether the CLI prompts for user input.
+ * Non-interactive mode is enabled by --yes flag or CI detection.
+ *
+ * @module cli/shared/interactive
+ */
+
+import { getEnv } from "../../src/platform/index.js";
+
+let _nonInteractive = false;
+
+export function setNonInteractive(enabled: boolean): void {
+  _nonInteractive = enabled;
+}
+
+export function isInteractive(): boolean {
+  return !_nonInteractive;
+}
+
+export function resetInteractiveMode(): void {
+  _nonInteractive = false;
+}
+
+const CI_ENV_VARS = ["CI", "GITHUB_ACTIONS", "GITLAB_CI", "JENKINS_URL", "CIRCLECI", "BUILDKITE"];
+
+export function detectCI(): boolean {
+  return CI_ENV_VARS.some((v) => {
+    const val = getEnv(v);
+    return val !== undefined && val !== "" && val !== "0" && val !== "false";
+  });
+}