veryfront 0.1.111 → 0.1.113

package/src/cli/commands/completions/command.ts

@@ -0,0 +1,163 @@
+/**
+ * Shell completion generators
+ *
+ * Generates completion scripts from the COMMANDS registry.
+ *
+ * @module cli/commands/completions
+ */
+
+import { COMMANDS } from "../../help/command-definitions.js";
+import type { CommandOption } from "../../help/types.js";
+
+/** Escape a string for use in shell single-quoted contexts */
+export function shellEscape(s: string): string {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+
+/**
+ * Extract long flags (--name) from a CommandOption flag string.
+ * Handles formats like: "--port", "-p, --port", "-p, --port <number>"
+ */
+export function extractLongFlags(options: CommandOption[]): string[] {
+  return options.flatMap((o) =>
+    o.flag
+      .split(",")
+      .map((f) => f.trim().split(" ")[0]!)
+      .filter((f) => f.startsWith("--"))
+  );
+}
+
+/**
+ * Extract short and long flags for fish completions.
+ * Returns { short: "p", long: "port" } pairs.
+ */
+export function extractFishFlags(
+  options: CommandOption[],
+): Array<{ short?: string; long?: string; description: string }> {
+  return options.map((o) => {
+    const parts = o.flag.split(",").map((f) => f.trim().split(" ")[0]!);
+    const short = parts.find((p) => p.match(/^-[a-zA-Z]$/))?.slice(1);
+    const long = parts.find((p) => p.startsWith("--"))?.slice(2);
+    return { short, long, description: o.description };
+  });
+}
+
+const GLOBAL_FLAGS = [
+  "--json",
+  "--yes",
+  "--quiet",
+  "--verbose",
+  "--help",
+  "--version",
+  "--no-color",
+  "--output",
+];
+
+export function generateBashCompletions(): string {
+  const commands = Object.values(COMMANDS);
+  const cmdNames = commands.map((c) => c.name).join(" ");
+
+  let script = `# Veryfront CLI bash completions\n_veryfront_completions() {\n`;
+  script += `  local cur prev commands\n`;
+  script += `  cur="\${COMP_WORDS[COMP_CWORD]}"\n`;
+  script += `  prev="\${COMP_WORDS[COMP_CWORD-1]}"\n`;
+  script += `  commands="${cmdNames}"\n\n`;
+  script += `  if [[ \${COMP_CWORD} -eq 1 ]]; then\n`;
+  script += `    COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )\n`;
+  script += `    return\n`;
+  script += `  fi\n\n`;
+  script += `  case "\${COMP_WORDS[1]}" in\n`;
+
+  for (const cmd of commands) {
+    const flags = extractLongFlags(cmd.options ?? [])
+      .concat(GLOBAL_FLAGS)
+      .join(" ");
+    script += `    ${cmd.name}) COMPREPLY=( $(compgen -W "${flags}" -- "\${cur}") ) ;;\n`;
+  }
+
+  script += `    *) COMPREPLY=( $(compgen -W "${GLOBAL_FLAGS.join(" ")}" -- "\${cur}") ) ;;\n`;
+  script += `  esac\n`;
+  script += `}\n`;
+  script += `complete -F _veryfront_completions veryfront\n`;
+  return script;
+}
+
+export function generateZshCompletions(): string {
+  const commands = Object.values(COMMANDS);
+  let script = `#compdef veryfront\n# Veryfront CLI zsh completions\n\n`;
+  script += `_veryfront() {\n`;
+  script += `  local -a commands\n`;
+  script += `  commands=(\n`;
+
+  for (const cmd of commands) {
+    const desc = shellEscape(cmd.description);
+    script += `    '${cmd.name}:${desc}'\n`;
+  }
+
+  script += `  )\n\n`;
+  script += `  _arguments -C \\\n`;
+  script += `    '1:command:->command' \\\n`;
+  script += `    '*::arg:->args'\n\n`;
+  script += `  case $state in\n`;
+  script += `    command)\n`;
+  script += `      _describe 'command' commands\n`;
+  script += `      ;;\n`;
+  script += `    args)\n`;
+  script += `      case \${words[1]} in\n`;
+
+  for (const cmd of commands) {
+    const flags = extractLongFlags(cmd.options ?? []).concat(GLOBAL_FLAGS);
+    if (flags.length > 0) {
+      const zshFlags = flags.map((f) =>
+        `'${f}[${
+          shellEscape(
+            (cmd.options ?? []).find((o) => o.flag.includes(f))?.description ??
+              "",
+          )
+        }]'`
+      ).join(" ");
+      script += `        ${cmd.name}) _arguments ${zshFlags} ;;\n`;
+    }
+  }
+
+  script += `      esac\n`;
+  script += `      ;;\n`;
+  script += `  esac\n`;
+  script += `}\n\n`;
+  script += `_veryfront\n`;
+  return script;
+}
+
+export function generateFishCompletions(): string {
+  const commands = Object.values(COMMANDS);
+  let script = `# Veryfront CLI fish completions\n`;
+
+  for (const cmd of commands) {
+    const desc = shellEscape(cmd.description);
+    script += `complete -c veryfront -n '__fish_use_subcommand' -a '${cmd.name}' -d '${desc}'\n`;
+  }
+
+  script += `\n`;
+
+  for (const cmd of commands) {
+    const flags = extractFishFlags(cmd.options ?? []);
+    for (const flag of flags) {
+      if (flag.long) {
+        const desc = shellEscape(flag.description);
+        let line =
+          `complete -c veryfront -n '__fish_seen_subcommand_from ${cmd.name}' -l '${flag.long}'`;
+        if (flag.short) {
+          line += ` -s '${flag.short}'`;
+        }
+        line += ` -d '${desc}'\n`;
+        script += line;
+      } else if (flag.short) {
+        const desc = shellEscape(flag.description);
+        script +=
+          `complete -c veryfront -n '__fish_seen_subcommand_from ${cmd.name}' -s '${flag.short}' -d '${desc}'\n`;
+      }
+    }
+  }
+
+  return script;
+}

package/src/cli/commands/completions/handler.ts

@@ -0,0 +1,29 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import type { ParsedArgs } from "../../shared/types.js";
+import {
+  generateBashCompletions,
+  generateFishCompletions,
+  generateZshCompletions,
+} from "./command.js";
+
+export async function handleCompletionsCommand(
+  args: ParsedArgs,
+): Promise<void> {
+  const shell = args._[1] as string | undefined;
+
+  switch (shell) {
+    case "bash":
+      console.log(generateBashCompletions());
+      break;
+    case "zsh":
+      console.log(generateZshCompletions());
+      break;
+    case "fish":
+      console.log(generateFishCompletions());
+      break;
+    default:
+      console.error("Usage: veryfront completions <bash|zsh|fish>");
+      console.error('Example: eval "$(veryfront completions bash)"');
+      dntShim.Deno.exit(1);
+  }
+}

package/src/cli/commands/demo/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const demoHelp: CommandHelp = {
   name: "demo",
+  category: "project",
   description: "Interactive guided tour of Veryfront CLI",
   usage: "veryfront demo [project-name] [options]",
   options: [

package/src/cli/commands/deploy/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const deployHelp: CommandHelp = {
   name: "deploy",
+  category: "deploy",
   description: "Create a release and deploy to an environment",
   usage: "veryfront deploy [options]",
   options: [

package/src/cli/commands/deploy/command.ts

@@ -13,6 +13,7 @@ import { type ApiClient, createApiClient, resolveConfigWithAuth } from "../../sh
 import { CommonArgs, createArgParser } from "../../shared/args.js";
 import { confirmPrompt, logInfo, logSuccess } from "../../utils/index.js";
 import { createNoopSpinner, createSpinner, muted } from "../../ui/index.js";
+import { isJsonMode, streamJsonLine } from "../../shared/json-output.js";
 
 /**
  * Zod schema for deploy command arguments
@@ -148,9 +149,12 @@ export function createDeployment(
 export async function deployCommand(options: DeployOptions): Promise<void> {
   const { branch, env, releaseName, dryRun, force, quiet } = options;
 
+  if (isJsonMode()) {
+    return deployCommandJson(options);
+  }
+
   let spinner = quiet ? createNoopSpinner() : createSpinner("Resolving configuration...");
 
-  // Use interactive auth - prompts for login if not authenticated
   const config = await resolveConfigWithAuth(cwd());
   const client = createApiClient(config);
 
@@ -196,3 +200,80 @@ export async function deployCommand(options: DeployOptions): Promise<void> {
   logInfo(`  Release: ${release.name} (${release.version})`);
   logInfo(`  Environment: ${env}`);
 }
+
+async function deployCommandJson(options: DeployOptions): Promise<void> {
+  const { branch, env, releaseName, dryRun, force } = options;
+
+  try {
+    // JSON mode requires --force or --yes to prevent accidental deploys
+    const { isInteractive } = await import("../../shared/interactive.js");
+    if (!force && isInteractive()) {
+      streamJsonLine({
+        type: "result",
+        success: false,
+        error:
+          "Deploy in JSON mode requires --force or --yes to confirm. This prevents accidental production deploys.",
+      });
+      const { exit } = await import("../../../src/platform/index.js");
+      exit(1);
+      return;
+    }
+
+    streamJsonLine({ type: "step", name: "resolve-config", status: "started" });
+    const config = await resolveConfigWithAuth(cwd());
+    const client = createApiClient(config);
+    streamJsonLine({ type: "step", name: "resolve-config", status: "completed" });
+
+    streamJsonLine({ type: "step", name: "resolve-environment", status: "started" });
+    const environment = await getEnvironmentByName(client, config.projectSlug, env);
+    if (!environment) {
+      streamJsonLine({
+        type: "result",
+        success: false,
+        error: `Environment "${env}" not found`,
+      });
+      const { exit } = await import("../../../src/platform/index.js");
+      exit(1);
+      return;
+    }
+    streamJsonLine({ type: "step", name: "resolve-environment", status: "completed" });
+
+    if (dryRun) {
+      streamJsonLine({
+        type: "result",
+        success: true,
+        data: { dryRun: true, branch, environment: env },
+      });
+      return;
+    }
+
+    streamJsonLine({ type: "step", name: "create-release", status: "started" });
+    const release = await createRelease(client, config.projectSlug, {
+      name: releaseName,
+      branch,
+    });
+    streamJsonLine({ type: "step", name: "create-release", status: "completed" });
+
+    streamJsonLine({ type: "step", name: "deploy", status: "started" });
+    await createDeployment(client, config.projectSlug, release.id, environment.id);
+    streamJsonLine({ type: "step", name: "deploy", status: "completed" });
+
+    streamJsonLine({
+      type: "result",
+      success: true,
+      data: {
+        release: { id: release.id, name: release.name, version: release.version },
+        environment: env,
+        branch,
+      },
+    });
+  } catch (error) {
+    streamJsonLine({
+      type: "result",
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    const { exit } = await import("../../../src/platform/index.js");
+    exit(1);
+  }
+}

package/src/cli/commands/dev/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const devHelp: CommandHelp = {
   name: "dev",
+  category: "development",
   description: "Start development server with hot module replacement",
   usage: "veryfront dev [options]",
   options: [

package/src/cli/commands/doctor/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const doctorHelp: CommandHelp = {
   name: "doctor",
+  category: "development",
   description: "Check system requirements and project health",
   usage: "veryfront doctor [options]",
   options: [

package/src/cli/commands/files/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const filesHelp: CommandHelp = {
   name: "files",
+  category: "files",
   description: "List, read, write, and delete project files",
   usage: "veryfront files <command> [options]",
   options: [

package/src/cli/commands/generate/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const generateHelp: CommandHelp = {
   name: "generate",
+  category: "development",
   description: "Generate code scaffolds",
   usage: "veryfront generate <type> [name]",
   options: [],

package/src/cli/commands/init/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const initHelp: CommandHelp = {
   name: "init",
+  category: "project",
   description: "Initialize a new Veryfront project",
   usage: "veryfront init [project-name] [options]",
   options: [

package/src/cli/commands/install/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const installHelp: CommandHelp = {
   name: "install",
+  category: "project",
   description: "Install AI assistant integrations (Cursor, Claude Code, etc.)",
   usage: "veryfront install [options]",
   options: [
@@ -35,6 +36,7 @@ export const installHelp: CommandHelp = {
 
 export const uninstallHelp: CommandHelp = {
   name: "uninstall",
+  category: "project",
   description: "Remove AI assistant integrations",
   usage: "veryfront uninstall [options]",
   options: [

package/src/cli/commands/issues/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const issuesHelp: CommandHelp = {
   name: "issues",
+  category: "ai",
   description: "File-based issue tracking (SDLC conventions)",
   usage: "veryfront issues <command> [options]",
   options: [

package/src/cli/commands/knowledge/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const knowledgeHelp: CommandHelp = {
   name: "knowledge",
+  category: "files",
   description: "Ingest documents into the project knowledge base",
   usage: "veryfront knowledge ingest <source...> [options]",
   options: [

package/src/cli/commands/lint/command-help.ts

@@ -0,0 +1,15 @@
+import type { CommandHelp } from "../../help/types.js";
+
+export const lintHelp: CommandHelp = {
+  name: "lint",
+  category: "development",
+  description: "Run linter with optional structured JSON output",
+  usage: "veryfront lint [options]",
+  options: [
+    { flag: "--json", description: "Output structured JSON results" },
+  ],
+  examples: [
+    "veryfront lint",
+    "veryfront lint --json",
+  ],
+};

package/src/cli/commands/lint/command.ts

@@ -0,0 +1,59 @@
+/**
+ * Lint wrapper command
+ *
+ * Runs deno lint and transforms output to structured JSON.
+ *
+ * @module cli/commands/lint
+ */
+
+export interface LintDiagnostic {
+  file: string;
+  line: number;
+  col: number;
+  code: string;
+  message: string;
+}
+
+export interface LintResult {
+  success: boolean;
+  diagnostics: LintDiagnostic[];
+  summary: {
+    total: number;
+    files_checked: number;
+  };
+}
+
+export function parseLintJsonOutput(output: string, exitCode: number): LintResult {
+  try {
+    const parsed = JSON.parse(output);
+    const diagnostics: LintDiagnostic[] = (parsed.diagnostics ?? []).map(
+      (d: {
+        filename?: string;
+        range?: { start?: { line?: number; col?: number } };
+        code?: string;
+        message?: string;
+      }) => ({
+        file: d.filename ?? "",
+        line: d.range?.start?.line ?? 0,
+        col: d.range?.start?.col ?? 0,
+        code: d.code ?? "",
+        message: d.message ?? "",
+      }),
+    );
+
+    return {
+      success: exitCode === 0,
+      diagnostics,
+      summary: {
+        total: diagnostics.length,
+        files_checked: new Set(diagnostics.map((d) => d.file)).size,
+      },
+    };
+  } catch {
+    return {
+      success: exitCode === 0,
+      diagnostics: [],
+      summary: { total: 0, files_checked: 0 },
+    };
+  }
+}

package/src/cli/commands/lint/handler.ts

@@ -0,0 +1,36 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import type { ParsedArgs } from "../../shared/types.js";
+import { createSuccessEnvelope, isJsonMode, outputJson } from "../../shared/json-output.js";
+import { parseLintJsonOutput } from "./command.js";
+
+export async function handleLintCommand(_args: ParsedArgs): Promise<void> {
+  const cmd = new dntShim.Deno.Command("deno", {
+    args: ["lint", "--json"],
+    stdout: "piped",
+    stderr: "piped",
+  });
+
+  const result = await cmd.output();
+  const stdout = new TextDecoder().decode(result.stdout);
+
+  if (isJsonMode()) {
+    const parsed = parseLintJsonOutput(stdout, result.code);
+    await outputJson(createSuccessEnvelope("lint", parsed));
+  } else {
+    if (result.code === 0) {
+      console.log("No lint issues found.");
+    } else {
+      // Re-run without --json for human-readable output
+      const humanCmd = new dntShim.Deno.Command("deno", {
+        args: ["lint"],
+        stdout: "inherit",
+        stderr: "inherit",
+      });
+      const humanResult = await humanCmd.output();
+      dntShim.Deno.exit(humanResult.code);
+      return;
+    }
+  }
+
+  dntShim.Deno.exit(result.code);
+}

package/src/cli/commands/lock/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const lockHelp: CommandHelp = {
   name: "lock",
+  category: "deploy",
   description: "Manage remote import lockfile for reproducible builds",
   usage: "veryfront lock [options]",
   options: [

package/src/cli/commands/login/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const loginHelp: CommandHelp = {
   name: "login",
+  category: "auth",
   description: "Authenticate with Veryfront",
   usage: "veryfront login [options]",
   options: [

package/src/cli/commands/logout/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const logoutHelp: CommandHelp = {
   name: "logout",
+  category: "auth",
   description: "Clear stored authentication credentials",
   usage: "veryfront logout",
   options: [],

package/src/cli/commands/mcp/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const mcpHelp: CommandHelp = {
   name: "mcp",
+  category: "ai",
   description: "Start MCP server for coding agents",
   usage: "veryfront mcp",
   options: [],

package/src/cli/commands/merge/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const mergeHelp: CommandHelp = {
   name: "merge",
+  category: "deploy",
   description: "Merge a branch into main (or another branch)",
   usage: "veryfront merge <branch> [options]",
   options: [

package/src/cli/commands/pull/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const pullHelp: CommandHelp = {
   name: "pull",
+  category: "deploy",
   description: "Download project files from Veryfront remote",
   usage: "veryfront pull [options]",
   options: [

package/src/cli/commands/push/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const pushHelp: CommandHelp = {
   name: "push",
+  category: "deploy",
   description: "Create a branch and upload local files to Veryfront",
   usage: "veryfront push [options]",
   options: [

package/src/cli/commands/routes/command-help.ts

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const routesHelp: CommandHelp = {
   name: "routes",
+  category: "development",
   description: "List all discovered routes in your application",
   usage: "veryfront routes [options]",
   options: [

package/src/cli/commands/schema/command-help.ts

@@ -0,0 +1,17 @@
+import type { CommandHelp } from "../../help/types.js";
+
+export const schemaHelp: CommandHelp = {
+  name: "schema",
+  category: "development",
+  description: "Show CLI command schema for agent discovery",
+  usage: "veryfront schema [command] [options]",
+  options: [
+    { flag: "--json", description: "Output as JSON (default for this command)" },
+    { flag: "--category <cat>", description: "Filter commands by category" },
+  ],
+  examples: [
+    "veryfront schema --json",
+    "veryfront schema deploy --json",
+    "veryfront schema --category ai --json",
+  ],
+};

package/src/cli/commands/schema/command.ts

@@ -0,0 +1,64 @@
+/**
+ * Schema introspection command
+ *
+ * Generates a machine-readable description of all CLI commands,
+ * their arguments, flags, and output schemas.
+ * Single source of truth: derived from COMMANDS registry and help definitions.
+ *
+ * @module cli/commands/schema
+ */
+
+import { COMMANDS } from "../../help/command-definitions.js";
+import type { CommandCategory, CommandHelp } from "../../help/types.js";
+import { VERSION } from "../../utils/index.js";
+
+export interface CommandSchema {
+  name: string;
+  category: string;
+  description: string;
+  usage: string;
+  options: Array<{
+    flag: string;
+    description: string;
+    default?: string;
+  }>;
+  flags: string[];
+  examples: string[];
+}
+
+export interface FullSchema {
+  version: string;
+  commands: CommandSchema[];
+}
+
+function commandToSchema(help: CommandHelp): CommandSchema {
+  const globalFlags = ["--json", "--quiet", "--verbose", "--yes", "--help"];
+
+  return {
+    name: help.name,
+    category: help.category,
+    description: help.description,
+    usage: help.usage,
+    options: (help.options ?? []).map((o) => ({
+      flag: o.flag,
+      description: o.description,
+      ...(o.default ? { default: o.default } : {}),
+    })),
+    flags: globalFlags,
+    examples: help.examples ?? [],
+  };
+}
+
+export function generateSchema(category?: CommandCategory): FullSchema {
+  const commands = Object.values(COMMANDS)
+    .filter((cmd) => !category || cmd.category === category)
+    .map(commandToSchema);
+
+  return { version: VERSION, commands };
+}
+
+export function generateCommandSchema(name: string): CommandSchema | null {
+  const help = COMMANDS[name];
+  if (!help) return null;
+  return commandToSchema(help);
+}