veryfront 0.1.111 → 0.1.113

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

@@ -0,0 +1,32 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { z } from "zod";
+import { createArgParser, parseArgsOrThrow } from "../../shared/args.js";
+import type { ParsedArgs } from "../../shared/types.js";
+import type { CommandCategory } from "../../help/types.js";
+import { generateCommandSchema, generateSchema } from "./command.js";
+
+const SchemaArgsSchema = z.object({
+  category: z.string().optional(),
+});
+
+const parseSchemaArgs = createArgParser(SchemaArgsSchema, {
+  category: { keys: ["category", "c"], type: "string" },
+});
+
+export async function handleSchemaCommand(args: ParsedArgs): Promise<void> {
+  const opts = parseArgsOrThrow(parseSchemaArgs, "schema", args);
+  const commandName = args._[1] as string | undefined;
+
+  if (commandName) {
+    const schema = generateCommandSchema(commandName);
+    if (!schema) {
+      console.error(`Unknown command: ${commandName}`);
+      dntShim.Deno.exit(1);
+    }
+    console.log(JSON.stringify(schema, null, 2));
+    return;
+  }
+
+  const schema = generateSchema(opts.category as CommandCategory | undefined);
+  console.log(JSON.stringify(schema, null, 2));
+}

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

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const serveHelp: CommandHelp = {
   name: "serve",
+  category: "development",
   description: "Start production server",
   usage: "veryfront serve [options]",
   options: [

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

@@ -0,0 +1,23 @@
+import type { CommandHelp } from "../../help/types.js";
+
+export const skillsHelp: CommandHelp = {
+  name: "skills",
+  category: "ai",
+  description: "List and inspect available agent skills",
+  usage: "veryfront skills [subcommand] [options]",
+  options: [
+    { flag: "--json", description: "Output as JSON" },
+  ],
+  examples: [
+    "veryfront skills list",
+    "veryfront skills list --json",
+    "veryfront skills info scaffold-app",
+    "veryfront skills info deploy-safely --json",
+    "veryfront skills create my-skill",
+    "veryfront skills validate ./my-skill",
+  ],
+  notes: [
+    "Subcommands: list (default), info, create, validate",
+    "Skills provide step-by-step agent workflows using CLI commands and MCP tools",
+  ],
+};

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

@@ -0,0 +1,23 @@
+/**
+ * Skills command — list and inspect agent skills
+ *
+ * @module cli/commands/skills
+ */
+
+import { listAllSkills, loadSkill } from "../../skills/loader.js";
+import type { LoadedSkill } from "../../skills/types.js";
+
+export async function listSkills(): Promise<LoadedSkill[]> {
+  return await listAllSkills();
+}
+
+export async function getSkillInfo(
+  name: string,
+): Promise<LoadedSkill | null> {
+  const skills = await listAllSkills();
+  const found = skills.find((s) => s.manifest.name === name);
+  if (found) return found;
+
+  // Try loading directly by path
+  return await loadSkill(name);
+}

package/src/cli/commands/skills/create.ts

@@ -0,0 +1,87 @@
+/**
+ * Skills create command — scaffold a new skill
+ *
+ * @module cli/commands/skills/create
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import type { ParsedArgs } from "../../shared/types.js";
+import { createSuccessEnvelope, isJsonMode, outputJson } from "../../shared/json-output.js";
+import { logSuccess } from "../../utils/index.js";
+import { createFileSystem } from "../../../src/platform/index.js";
+
+const VALID_SKILL_NAME = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+
+const SKILL_JSON_TEMPLATE = (name: string) =>
+  JSON.stringify(
+    {
+      name,
+      version: "1.0.0",
+      description: `${name} skill`,
+      requires: {
+        cli: [],
+        mcp: [],
+      },
+      inputs: {},
+    },
+    null,
+    2,
+  );
+
+const SKILL_MD_TEMPLATE = (name: string) =>
+  `# ${name}
+
+## Overview
+
+Describe what this skill does.
+
+## Steps
+
+1. **Step 1** — Description
+   \`\`\`bash
+   veryfront <command> --json
+   \`\`\`
+
+2. **Step 2** — Description
+
+## Error Recovery
+
+- If step 1 fails: ...
+- If step 2 fails: ...
+`;
+
+export async function createSkill(args: ParsedArgs): Promise<void> {
+  const name = args._[2] as string | undefined;
+  if (!name) {
+    console.error("Usage: veryfront skills create <name>");
+    dntShim.Deno.exit(1);
+  }
+
+  if (!VALID_SKILL_NAME.test(name)) {
+    console.error(
+      `Invalid skill name "${name}". Use lowercase letters, numbers, and hyphens (e.g. "my-skill").`,
+    );
+    dntShim.Deno.exit(1);
+  }
+
+  const fs = createFileSystem();
+  const dir = name;
+
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeTextFile(`${dir}/skill.json`, SKILL_JSON_TEMPLATE(name));
+  await fs.writeTextFile(`${dir}/SKILL.md`, SKILL_MD_TEMPLATE(name));
+
+  if (isJsonMode()) {
+    await outputJson(
+      createSuccessEnvelope("skills", {
+        created: name,
+        files: [`${dir}/skill.json`, `${dir}/SKILL.md`],
+      }),
+    );
+    return;
+  }
+
+  logSuccess(`Created skill "${name}" at ./${dir}/`);
+  console.log(`  Files: skill.json, SKILL.md`);
+}

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

@@ -0,0 +1,106 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import type { ParsedArgs } from "../../shared/types.js";
+import { createSuccessEnvelope, isJsonMode, outputJson } from "../../shared/json-output.js";
+import { getSkillInfo, listSkills } from "./command.js";
+import { bold, dim } from "../../ui/colors.js";
+
+export async function handleSkillsCommand(args: ParsedArgs): Promise<void> {
+  const subcommand = args._[1] as string | undefined;
+
+  switch (subcommand) {
+    case "info":
+      return await handleSkillInfo(args);
+    case "create":
+      return await handleSkillCreate(args);
+    case "validate":
+      return await handleSkillValidate(args);
+    case "list":
+    default:
+      return await handleSkillList();
+  }
+}
+
+async function handleSkillList(): Promise<void> {
+  const skills = await listSkills();
+
+  if (isJsonMode()) {
+    await outputJson(
+      createSuccessEnvelope(
+        "skills",
+        skills.map((s) => ({
+          name: s.manifest.name,
+          version: s.manifest.version,
+          description: s.manifest.description,
+          requires: s.manifest.requires,
+        })),
+      ),
+    );
+    return;
+  }
+
+  if (skills.length === 0) {
+    console.log(`  ${dim("No skills found.")}`);
+    console.log(
+      `  ${dim("Skills are located in cli/mcp/skills/")}`,
+    );
+    return;
+  }
+
+  console.log(`\n  ${bold("Available Skills")}\n`);
+  for (const skill of skills) {
+    console.log(
+      `  ${bold(skill.manifest.name)} ${dim(`v${skill.manifest.version}`)}`,
+    );
+    console.log(`    ${skill.manifest.description}`);
+  }
+  console.log();
+}
+
+async function handleSkillInfo(args: ParsedArgs): Promise<void> {
+  const name = args._[2] as string | undefined;
+  if (!name) {
+    console.error("Usage: veryfront skills info <name>");
+    dntShim.Deno.exit(1);
+  }
+
+  const skill = await getSkillInfo(name);
+  if (!skill) {
+    console.error(`Skill not found: ${name}`);
+    dntShim.Deno.exit(1);
+  }
+
+  if (isJsonMode()) {
+    await outputJson(
+      createSuccessEnvelope("skills", {
+        ...skill.manifest,
+        content: skill.skillMd,
+        directory: skill.directory,
+      }),
+    );
+    return;
+  }
+
+  console.log(`\n  ${bold(skill.manifest.name)} ${dim(`v${skill.manifest.version}`)}`);
+  console.log(`  ${skill.manifest.description}\n`);
+  if (skill.manifest.requires) {
+    if (skill.manifest.requires.cli?.length) {
+      console.log(`  ${dim("CLI:")} ${skill.manifest.requires.cli.join(", ")}`);
+    }
+    if (skill.manifest.requires.mcp?.length) {
+      console.log(`  ${dim("MCP:")} ${skill.manifest.requires.mcp.join(", ")}`);
+    }
+  }
+  if (skill.skillMd) {
+    console.log(`\n${skill.skillMd}`);
+  }
+}
+
+async function handleSkillCreate(args: ParsedArgs): Promise<void> {
+  const { createSkill } = await import("./create.js");
+  await createSkill(args);
+}
+
+async function handleSkillValidate(args: ParsedArgs): Promise<void> {
+  const { validateSkill } = await import("./validate.js");
+  await validateSkill(args);
+}

package/src/cli/commands/skills/validate.ts

@@ -0,0 +1,110 @@
+/**
+ * Skills validate command — validate a skill directory
+ *
+ * @module cli/commands/skills/validate
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import type { ParsedArgs } from "../../shared/types.js";
+import { createSuccessEnvelope, isJsonMode, outputJson } from "../../shared/json-output.js";
+import { parseSkillJson } from "../../skills/types.js";
+import { COMMANDS } from "../../help/command-definitions.js";
+import { logError, logSuccess } from "../../utils/index.js";
+import { createFileSystem } from "../../../src/platform/index.js";
+
+interface ValidationIssue {
+  severity: "error" | "warning";
+  message: string;
+}
+
+export async function validateSkill(args: ParsedArgs): Promise<void> {
+  const dir = (args._[2] as string | undefined) ?? ".";
+  const issues: ValidationIssue[] = [];
+  const fs = createFileSystem();
+
+  // Check skill.json exists and parses
+  let manifestRaw: string;
+  try {
+    manifestRaw = await fs.readTextFile(`${dir}/skill.json`);
+  } catch {
+    issues.push({ severity: "error", message: "skill.json not found" });
+    return outputResults(dir, issues);
+  }
+
+  let parsed: ReturnType<typeof parseSkillJson>;
+  try {
+    parsed = parseSkillJson(JSON.parse(manifestRaw));
+  } catch {
+    issues.push({
+      severity: "error",
+      message: "skill.json is not valid JSON",
+    });
+    return outputResults(dir, issues);
+  }
+
+  if (!parsed.success) {
+    issues.push({
+      severity: "error",
+      message: `skill.json schema error: ${parsed.error}`,
+    });
+    return outputResults(dir, issues);
+  }
+
+  // Check SKILL.md exists
+  try {
+    const content = await fs.readTextFile(`${dir}/SKILL.md`);
+    if (!content.trim()) {
+      issues.push({ severity: "warning", message: "SKILL.md is empty" });
+    }
+  } catch {
+    issues.push({ severity: "error", message: "SKILL.md not found" });
+  }
+
+  // Check required CLI commands exist
+  const cliReqs = parsed.data.requires?.cli ?? [];
+  for (const cmd of cliReqs) {
+    if (!COMMANDS[cmd]) {
+      issues.push({
+        severity: "warning",
+        message: `Required CLI command "${cmd}" not found in registry`,
+      });
+    }
+  }
+
+  return outputResults(dir, issues);
+}
+
+async function outputResults(
+  dir: string,
+  issues: ValidationIssue[],
+): Promise<void> {
+  const hasErrors = issues.some((i) => i.severity === "error");
+
+  if (isJsonMode()) {
+    await outputJson(
+      createSuccessEnvelope("skills", {
+        directory: dir,
+        valid: !hasErrors,
+        issues,
+      }),
+    );
+    if (hasErrors) dntShim.Deno.exit(1);
+    return;
+  }
+
+  if (issues.length === 0) {
+    logSuccess(`Skill at "${dir}" is valid`);
+    return;
+  }
+
+  for (const issue of issues) {
+    if (issue.severity === "error") {
+      logError(issue.message);
+    } else {
+      console.log(`  ! ${issue.message}`);
+    }
+  }
+
+  if (hasErrors) dntShim.Deno.exit(1);
+}

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

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const startHelp: CommandHelp = {
   name: "start",
+  category: "project",
   description: "Start development dashboard with proxy and MCP integration",
   usage: "veryfront start [options]",
   options: [

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

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const studioHelp: CommandHelp = {
   name: "studio",
+  category: "project",
   description: "Open Veryfront Studio in browser",
   usage: "veryfront studio [project] [options]",
   options: [

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

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const stylesHelp: CommandHelp = {
   name: "styles",
+  category: "development",
   description: "Build project CSS artifacts",
   usage: "veryfront styles build-artifact --config <json>",
   options: [

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

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const taskHelp: CommandHelp = {
   name: "task",
+  category: "ai",
   description: "Run a task from the tasks/ directory",
   usage: "veryfront task <name> [options]",
   options: [

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

@@ -0,0 +1,18 @@
+import type { CommandHelp } from "../../help/types.js";
+
+export const testHelp: CommandHelp = {
+  name: "test",
+  category: "development",
+  description: "Run tests with optional structured JSON output",
+  usage: "veryfront test [filter] [options]",
+  options: [
+    { flag: "--json", description: "Output structured JSON results" },
+    { flag: "--parallel", description: "Run tests in parallel" },
+    { flag: "--filter <pattern>", description: "Filter tests by name" },
+  ],
+  examples: [
+    "veryfront test",
+    "veryfront test --json",
+    "veryfront test --filter 'deploy' --json",
+  ],
+};

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

@@ -0,0 +1,90 @@
+/**
+ * Test wrapper command
+ *
+ * Runs deno test and transforms output to structured JSON.
+ *
+ * @module cli/commands/test
+ */
+
+export interface TestResult {
+  success: boolean;
+  summary: {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration_ms: number;
+  };
+  failures: Array<{
+    file: string;
+    test: string;
+    error: string;
+    line?: number;
+  }>;
+}
+
+export function parseTestOutput(output: string, exitCode: number): TestResult {
+  const lines = output.split("\n");
+
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  let durationMs = 0;
+
+  for (const line of lines) {
+    const summaryMatch = line.match(/(\d+)\s+passed\s*\|\s*(\d+)\s+failed/);
+    if (summaryMatch) {
+      passed = parseInt(summaryMatch[1] ?? "0", 10);
+      failed = parseInt(summaryMatch[2] ?? "0", 10);
+    }
+
+    const durationMatch = line.match(/\((\d+\.?\d*)s\)/);
+    if (durationMatch) {
+      durationMs = Math.round(parseFloat(durationMatch[1] ?? "0") * 1000);
+    }
+
+    const skippedMatch = line.match(/(\d+)\s+ignored/);
+    if (skippedMatch) {
+      skipped = parseInt(skippedMatch[1] ?? "0", 10);
+    }
+  }
+
+  const failures: TestResult["failures"] = [];
+  const failureRegex = /^(.*?)\s+\.\.\.\s+FAILED/;
+  for (let i = 0; i < lines.length; i++) {
+    const currentLine = lines[i];
+    if (!currentLine) continue;
+    const match = currentLine.match(failureRegex);
+    if (match) {
+      const testName = (match[1] ?? "").trim();
+      let error = "";
+      let file = "";
+      let line: number | undefined;
+      for (let j = i + 1; j < Math.min(i + 10, lines.length); j++) {
+        const lineText = lines[j];
+        if (!lineText) continue;
+        const fileLine = lineText.match(/at\s+(.*?):(\d+)/);
+        if (fileLine?.[1] && fileLine[2]) {
+          file = fileLine[1];
+          line = parseInt(fileLine[2], 10);
+        }
+        if (lineText.includes("Error:") || lineText.includes("assert")) {
+          error = lineText.trim();
+        }
+      }
+      failures.push({ file, test: testName, error, line });
+    }
+  }
+
+  return {
+    success: exitCode === 0,
+    summary: {
+      total: passed + failed + skipped,
+      passed,
+      failed,
+      skipped,
+      duration_ms: durationMs,
+    },
+    failures,
+  };
+}

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

@@ -0,0 +1,70 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { z } from "zod";
+import { createArgParser, parseArgsOrThrow } from "../../shared/args.js";
+import type { ParsedArgs } from "../../shared/types.js";
+import {
+  createErrorEnvelope,
+  createSuccessEnvelope,
+  isJsonMode,
+  outputJson,
+} from "../../shared/json-output.js";
+import { parseTestOutput } from "./command.js";
+
+const TestArgsSchema = z.object({
+  filter: z.string().optional(),
+  parallel: z.boolean().default(false),
+});
+
+const parseTestArgs = createArgParser(TestArgsSchema, {
+  filter: { keys: ["filter"], type: "string", positional: 0 },
+  parallel: { keys: ["parallel"], type: "boolean" },
+});
+
+export async function handleTestCommand(args: ParsedArgs): Promise<void> {
+  const opts = parseArgsOrThrow(parseTestArgs, "test", args);
+
+  const cmd = new dntShim.Deno.Command("deno", {
+    args: [
+      "test",
+      "--no-check",
+      "--allow-all",
+      "--unstable-worker-options",
+      "--unstable-net",
+      ...(opts.parallel ? ["--parallel"] : []),
+      ...(opts.filter ? [`--filter=${opts.filter}`] : []),
+    ],
+    stdout: "piped",
+    stderr: "piped",
+    env: {
+      VF_DISABLE_LRU_INTERVAL: "1",
+      SSR_TRANSFORM_PER_PROJECT_LIMIT: "0",
+      REVALIDATION_PER_PROJECT_LIMIT: "0",
+      NODE_ENV: "production",
+      LOG_FORMAT: "text",
+    },
+  });
+
+  const result = await cmd.output();
+  const stdout = new TextDecoder().decode(result.stdout);
+  const stderr = new TextDecoder().decode(result.stderr);
+  const fullOutput = stdout + "\n" + stderr;
+
+  if (isJsonMode()) {
+    const parsed = parseTestOutput(fullOutput, result.code);
+    if (parsed.success) {
+      await outputJson(createSuccessEnvelope("test", parsed));
+    } else {
+      await outputJson(createErrorEnvelope("test", {
+        code: "TEST_FAILURE",
+        slug: "tests-failed",
+        message: `${parsed.summary.failed} test(s) failed`,
+        context: parsed as unknown as Record<string, unknown>,
+      }));
+    }
+  } else {
+    if (stdout) console.log(stdout);
+    if (stderr) console.error(stderr);
+  }
+
+  dntShim.Deno.exit(result.code);
+}

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

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const upHelp: CommandHelp = {
   name: "up",
+  category: "deploy",
   description: "Deploy your app with one command (login, create, push, deploy)",
   usage: "veryfront up [options]",
   options: [

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

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

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

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const whoamiHelp: CommandHelp = {
   name: "whoami",
+  category: "auth",
   description: "Show current authenticated user",
   usage: "veryfront whoami",
   options: [],

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

@@ -2,6 +2,7 @@ import type { CommandHelp } from "../../help/types.js";
 
 export const workflowHelp: CommandHelp = {
   name: "workflow",
+  category: "ai",
   description: "Run a workflow from the app/workflows directory",
   usage: "veryfront workflow run <id> [options]",
   options: [

package/src/cli/help/command-definitions.ts

@@ -38,6 +38,11 @@ import { issuesHelp } from "../commands/issues/command-help.js";
 import { startHelp } from "../commands/start/command-help.js";
 import { taskHelp } from "../commands/task/command-help.js";
 import { workflowHelp } from "../commands/workflow/command-help.js";
+import { schemaHelp } from "../commands/schema/command-help.js";
+import { testHelp } from "../commands/test/command-help.js";
+import { lintHelp } from "../commands/lint/command-help.js";
+import { skillsHelp } from "../commands/skills/command-help.js";
+import { completionsHelp } from "../commands/completions/command-help.js";
 
 /**
  * Central registry of all command help definitions.
@@ -75,4 +80,9 @@ export const COMMANDS: CommandRegistry = {
   start: startHelp,
   task: taskHelp,
   workflow: workflowHelp,
+  schema: schemaHelp,
+  test: testHelp,
+  lint: lintHelp,
+  skills: skillsHelp,
+  completions: completionsHelp,
 };