@qlucent/fishi 0.6.0 → 0.8.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk8 from "chalk";
+import chalk11 from "chalk";
 
 // src/commands/init.ts
 import chalk from "chalk";
@@ -10,7 +10,7 @@ import ora from "ora";
 import inquirer from "inquirer";
 import path3 from "path";
 import fs3 from "fs";
-import { detectConflicts, createBackup } from "@qlucent/fishi-core";
+import { detectConflicts, createBackup, detectDocker } from "@qlucent/fishi-core";
 
 // src/analyzers/detector.ts
 import fs from "fs";
@@ -1005,6 +1005,23 @@ async function initCommand(description, options) {
   } else {
     initOptions = await runWizard(options);
   }
+  const dockerAvailable = detectDocker();
+  let sandboxMode = "process";
+  if (options.interactive !== false) {
+    if (dockerAvailable) {
+      const { useSandbox } = await inquirer.prompt([{
+        type: "confirm",
+        name: "useSandbox",
+        message: "Docker detected. Use Docker sandbox for agent isolation? (Recommended)",
+        default: true
+      }]);
+      sandboxMode = useSandbox ? "docker" : "process";
+    } else {
+      console.log(chalk.yellow("  Docker not found. Using process-level sandbox (limited isolation)."));
+      console.log(chalk.gray("  Install Docker for full agent isolation: https://docs.docker.com/get-docker/"));
+      console.log("");
+    }
+  }
   let brownfieldAnalysis = null;
   if (detection.type === "brownfield" || detection.type === "hybrid") {
     console.log("");
@@ -1148,6 +1165,21 @@ async function initCommand(description, options) {
       const report = generateBrownfieldReport(brownfieldAnalysis);
       fs3.writeFileSync(reportPath, report, "utf-8");
     }
+    const sandboxYaml = `
+sandbox:
+  mode: ${sandboxMode}
+  docker_available: ${dockerAvailable}
+`;
+    const fishiYamlPath = path3.join(targetDir, ".fishi", "fishi.yaml");
+    if (fs3.existsSync(fishiYamlPath)) {
+      fs3.appendFileSync(fishiYamlPath, sandboxYaml, "utf-8");
+    }
+    const { getSandboxPolicyTemplate, getDockerfileTemplate } = await import("@qlucent/fishi-core");
+    fs3.writeFileSync(path3.join(targetDir, ".fishi", "sandbox-policy.yaml"), getSandboxPolicyTemplate(), "utf-8");
+    if (sandboxMode === "docker") {
+      fs3.mkdirSync(path3.join(targetDir, ".fishi", "docker"), { recursive: true });
+      fs3.writeFileSync(path3.join(targetDir, ".fishi", "docker", "Dockerfile"), getDockerfileTemplate(), "utf-8");
+    }
     scaffoldSpinner.succeed("FISHI framework scaffolded successfully!");
     console.log("");
     console.log(chalk.bold("  Created:"));
@@ -1158,6 +1190,7 @@ async function initCommand(description, options) {
     console.log(chalk.gray(`  \u{1F4C4} .claude/CLAUDE.md       \u2014 Project instructions`));
     console.log(chalk.gray(`  \u{1F4C4} .claude/settings.json   \u2014 Hooks & permissions`));
     console.log(chalk.gray(`  \u{1F4C4} .mcp.json               \u2014 MCP server config`));
+    console.log(chalk.gray(`  \u{1F512} Sandbox:              ${sandboxMode} mode${sandboxMode === "docker" ? " (full isolation)" : " (limited isolation)"}`));
     if (brownfieldAnalysis) {
       console.log(chalk.gray(`  \u{1F4C4} .fishi/memory/brownfield-analysis.md \u2014 Codebase analysis report`));
       console.log("");
@@ -1898,11 +1931,241 @@ async function dashboardCommand(options) {
   });
 }
 
+// src/commands/sandbox.ts
+import chalk8 from "chalk";
+import fs10 from "fs";
+import path10 from "path";
+import { detectDocker as detectDocker2, readSandboxConfig, readSandboxPolicy } from "@qlucent/fishi-core";
+async function sandboxCommand(action) {
+  const targetDir = process.cwd();
+  if (!fs10.existsSync(path10.join(targetDir, ".fishi"))) {
+    console.log(chalk8.yellow("  No FISHI project found. Run `fishi init` first."));
+    return;
+  }
+  if (action === "status") {
+    const config = readSandboxConfig(targetDir);
+    const dockerNow = detectDocker2();
+    console.log("");
+    console.log(chalk8.cyan.bold("  FISHI Sandbox Status"));
+    console.log("");
+    console.log(chalk8.white("  Mode:             ") + (config.mode === "docker" ? chalk8.green("Docker") : chalk8.yellow("Process")));
+    console.log(chalk8.white("  Docker available:  ") + (dockerNow ? chalk8.green("yes") : chalk8.red("no")));
+    if (config.mode === "docker" && !dockerNow) {
+      console.log(chalk8.red("  Warning: Docker mode configured but Docker not available!"));
+    }
+    console.log("");
+    const policy = readSandboxPolicy(targetDir);
+    console.log(chalk8.white.bold("  Policy"));
+    console.log(chalk8.gray(`    Timeout:         ${policy.timeout}s`));
+    console.log(chalk8.gray(`    Memory limit:    ${policy.memory}`));
+    console.log(chalk8.gray(`    CPU limit:       ${policy.cpus}`));
+    console.log(chalk8.gray(`    Network allow:   ${policy.networkAllow.join(", ")}`));
+    console.log(chalk8.gray(`    Env passthrough: ${policy.envPassthrough.length > 0 ? policy.envPassthrough.join(", ") : "(none)"}`));
+    console.log("");
+  } else if (action === "policy") {
+    const policy = readSandboxPolicy(targetDir);
+    console.log(JSON.stringify(policy, null, 2));
+  } else {
+    console.log(chalk8.yellow(`  Unknown action: ${action}. Use: status, policy`));
+  }
+}
+
+// src/commands/quickstart.ts
+import chalk9 from "chalk";
+import ora2 from "ora";
+import path11 from "path";
+import fs11 from "fs";
+import { detectDevServer, startDevServer, getVibeModeConfig } from "@qlucent/fishi-core";
+import { detectConflicts as detectConflicts2, createBackup as createBackup2 } from "@qlucent/fishi-core";
+import { detectDocker as detectDocker3 } from "@qlucent/fishi-core";
+async function quickstartCommand(description, options) {
+  const targetDir = process.cwd();
+  const projectName = path11.basename(targetDir);
+  console.log("");
+  console.log(chalk9.cyan.bold("  FISHI \u2014 Vibe Mode"));
+  console.log(chalk9.gray("  Skip the ceremony, start shipping"));
+  console.log("");
+  if (fs11.existsSync(path11.join(targetDir, ".fishi"))) {
+    console.log(chalk9.yellow("  FISHI already initialized. Starting dev server only..."));
+    const serverConfig2 = detectDevServer(targetDir, options.devCmd);
+    if (serverConfig2.detected) {
+      console.log(chalk9.green(`  Starting ${serverConfig2.framework} dev server on :${serverConfig2.port}...`));
+      const child = startDevServer(targetDir, serverConfig2);
+      child.stdout?.on("data", (d) => process.stdout.write(d));
+      child.stderr?.on("data", (d) => process.stderr.write(d));
+      child.on("close", (code) => process.exit(code || 0));
+      return;
+    }
+    console.log(chalk9.yellow("  Could not detect dev server. Use --dev-cmd to specify."));
+    return;
+  }
+  const spinner = ora2("Analyzing project...").start();
+  const detection = await detectProjectType(targetDir);
+  spinner.succeed(`Project type: ${chalk9.bold(detection.type)}`);
+  let brownfieldAnalysis = null;
+  if (detection.type === "brownfield" || detection.type === "hybrid") {
+    const analysisSpinner = ora2("Running brownfield analysis...").start();
+    brownfieldAnalysis = await runBrownfieldAnalysis(targetDir);
+    analysisSpinner.succeed("Brownfield analysis complete");
+  }
+  const conflictResult = detectConflicts2(targetDir);
+  let resolutions;
+  if (conflictResult.hasConflicts) {
+    console.log(chalk9.yellow(`  Auto-merging ${conflictResult.totalConflicts} conflicting files (vibe mode)...`));
+    const allPaths = conflictResult.categories.flatMap((c) => c.conflicts.map((f) => f.path));
+    await createBackup2(targetDir, allPaths);
+    resolutions = { categories: {}, files: {} };
+    for (const cat of conflictResult.categories) {
+      if (cat.conflicts.length > 0) {
+        const noMerge = ["agents", "skills", "commands"];
+        resolutions.categories[cat.name] = noMerge.includes(cat.name) ? "skip" : "merge";
+      }
+    }
+  }
+  const initOptions = {
+    description: description || `${projectName} project`,
+    interactive: false,
+    costMode: options.costMode || "balanced",
+    language: options.language || brownfieldAnalysis?.language,
+    framework: options.framework || brownfieldAnalysis?.framework
+  };
+  let brownfieldData = void 0;
+  if (brownfieldAnalysis) {
+    brownfieldData = {
+      language: brownfieldAnalysis.language,
+      framework: brownfieldAnalysis.framework,
+      testFramework: brownfieldAnalysis.testFramework,
+      packageManager: brownfieldAnalysis.packageManager,
+      linter: brownfieldAnalysis.linter,
+      formatter: brownfieldAnalysis.formatter,
+      cssFramework: brownfieldAnalysis.cssFramework,
+      orm: brownfieldAnalysis.orm,
+      database: brownfieldAnalysis.database,
+      authProvider: brownfieldAnalysis.authProvider,
+      apiStyle: brownfieldAnalysis.apiStyle,
+      monorepo: brownfieldAnalysis.monorepo,
+      conventions: brownfieldAnalysis.conventions,
+      codePatterns: brownfieldAnalysis.codePatterns,
+      fileStats: {
+        totalFiles: brownfieldAnalysis.fileStats.totalFiles,
+        codeFiles: brownfieldAnalysis.fileStats.codeFiles,
+        testFiles: brownfieldAnalysis.fileStats.testFiles
+      }
+    };
+  }
+  const scaffoldSpinner = ora2("Scaffolding FISHI...").start();
+  try {
+    const result = await scaffold(targetDir, {
+      ...initOptions,
+      projectName,
+      projectType: detection.type,
+      brownfieldAnalysis: brownfieldData,
+      resolutions,
+      docsReadmeExists: conflictResult.docsReadmeExists,
+      rootClaudeMdExists: conflictResult.rootClaudeMdExists
+    });
+    scaffoldSpinner.succeed(`Scaffolded: ${result.agentCount} agents, ${result.skillCount} skills, ${result.commandCount} commands`);
+  } catch (error) {
+    scaffoldSpinner.fail("Scaffolding failed");
+    console.error(chalk9.red(`  Error: ${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+  const fishiYamlPath = path11.join(targetDir, ".fishi", "fishi.yaml");
+  if (fs11.existsSync(fishiYamlPath)) {
+    fs11.appendFileSync(fishiYamlPath, getVibeModeConfig(true), "utf-8");
+  }
+  const dockerAvailable = detectDocker3();
+  const sandboxMode = dockerAvailable ? "docker" : "process";
+  fs11.appendFileSync(fishiYamlPath, `
+sandbox:
+  mode: ${sandboxMode}
+  docker_available: ${dockerAvailable}
+`, "utf-8");
+  const projectYamlPath = path11.join(targetDir, ".fishi", "state", "project.yaml");
+  if (fs11.existsSync(projectYamlPath)) {
+    let content = fs11.readFileSync(projectYamlPath, "utf-8");
+    content = content.replace(/^phase:\s*.+$/m, "phase: development");
+    fs11.writeFileSync(projectYamlPath, content, "utf-8");
+  }
+  const serverConfig = detectDevServer(targetDir, options.devCmd);
+  console.log("");
+  console.log(chalk9.cyan.bold("  Vibe Mode Active"));
+  console.log(chalk9.gray(`  Phase: ${chalk9.green("development")} (gates auto-skipped)`));
+  console.log(chalk9.gray(`  Sandbox: ${sandboxMode}`));
+  if (serverConfig.detected) {
+    const port = options.port ? parseInt(options.port, 10) : serverConfig.port;
+    console.log(chalk9.gray(`  Dev server: ${serverConfig.framework} on :${port}`));
+    console.log("");
+    console.log(chalk9.green.bold(`  Preview: http://localhost:${port}`));
+    console.log("");
+    console.log(chalk9.gray("  Starting dev server..."));
+    console.log("");
+    const child = startDevServer(targetDir, { ...serverConfig, port });
+    child.stdout?.on("data", (d) => process.stdout.write(d));
+    child.stderr?.on("data", (d) => process.stderr.write(d));
+    child.on("close", (code) => {
+      console.log(chalk9.gray(`
+  Dev server stopped (exit ${code})`));
+    });
+    process.on("SIGINT", () => {
+      child.kill();
+      console.log(chalk9.gray("\n  Dev server stopped."));
+      process.exit(0);
+    });
+  } else {
+    console.log("");
+    console.log(chalk9.yellow("  No dev server detected. Run your dev server manually."));
+    console.log(chalk9.gray('  Or use: fishi quickstart --dev-cmd "npm run dev"'));
+    console.log("");
+    console.log(chalk9.cyan.bold("  Ready to ship!"));
+    console.log(chalk9.gray("  Run `claude` to start working with your AI dev team."));
+    console.log("");
+  }
+}
+
+// src/commands/preview.ts
+import chalk10 from "chalk";
+import fs12 from "fs";
+import path12 from "path";
+import { detectDevServer as detectDevServer2, startDevServer as startDevServer2 } from "@qlucent/fishi-core";
+async function previewCommand(options) {
+  const targetDir = process.cwd();
+  if (!fs12.existsSync(path12.join(targetDir, ".fishi"))) {
+    console.log(chalk10.yellow("  No FISHI project found. Run `fishi init` or `fishi quickstart` first."));
+    return;
+  }
+  const serverConfig = detectDevServer2(targetDir, options.devCmd);
+  if (!serverConfig.detected) {
+    console.log(chalk10.yellow("  Could not detect dev server."));
+    console.log(chalk10.gray('  Use --dev-cmd to specify: fishi preview --dev-cmd "npm run dev"'));
+    return;
+  }
+  const port = options.port ? parseInt(options.port, 10) : serverConfig.port;
+  console.log("");
+  console.log(chalk10.cyan.bold("  FISHI Live Preview"));
+  console.log(chalk10.gray(`  Framework: ${serverConfig.framework}`));
+  console.log(chalk10.green.bold(`  URL: http://localhost:${port}`));
+  console.log(chalk10.gray("  Press Ctrl+C to stop"));
+  console.log("");
+  const child = startDevServer2(targetDir, { ...serverConfig, port });
+  child.stdout?.on("data", (d) => process.stdout.write(d));
+  child.stderr?.on("data", (d) => process.stderr.write(d));
+  child.on("close", (code) => {
+    console.log(chalk10.gray(`
+  Dev server stopped (exit ${code})`));
+  });
+  process.on("SIGINT", () => {
+    child.kill();
+    console.log(chalk10.gray("\n  Dev server stopped."));
+    process.exit(0);
+  });
+}
+
 // src/index.ts
 var program = new Command();
 program.name("fishi").description(
-  chalk8.cyan("\u{1F41F} FISHI") + " \u2014 Your AI Dev Team That Actually Ships\n   Autonomous agent framework for Claude Code"
-).version("0.6.0");
+  chalk11.cyan("\u{1F41F} FISHI") + " \u2014 Your AI Dev Team That Actually Ships\n   Autonomous agent framework for Claude Code"
+).version("0.8.0");
 program.command("init").description("Initialize FISHI in the current directory").argument("[description]", "Project description (skip wizard with zero-config)").option("-l, --language <lang>", "Primary language (e.g., typescript, python)").option("-f, --framework <framework>", "Framework (e.g., nextjs, express, django)").option(
   "-c, --cost-mode <mode>",
   "Cost mode: performance | balanced | economy",
@@ -1914,4 +2177,7 @@ program.command("reset").description("Rollback to a previous checkpoint").argume
 program.command("validate").description("Validate scaffold integrity \u2014 checks files, frontmatter, cross-references, pipeline, and permissions").action(validateCommand);
 program.command("monitor").description("Agent observability \u2014 TUI dashboard showing agent activity, tokens, gates").option("-w, --watch", "Watch mode \u2014 auto-refresh on changes").action(monitorCommand);
 program.command("dashboard").description("Agent observability \u2014 web dashboard at http://localhost:4269").option("-p, --port <port>", "Port number", "4269").action(dashboardCommand);
+program.command("sandbox").description("Sandbox status and policy management").argument("<action>", "Action: status | policy").action(sandboxCommand);
+program.command("quickstart").description("Vibe mode \u2014 skip gates, scaffold + start dev server immediately").argument("[description]", "What are you building?").option("-l, --language <lang>", "Primary language").option("-f, --framework <framework>", "Framework").option("-c, --cost-mode <mode>", "Cost mode", "balanced").option("--dev-cmd <cmd>", "Custom dev server command").option("--port <port>", "Dev server port").action(quickstartCommand);
+program.command("preview").description("Start live preview dev server").option("--dev-cmd <cmd>", "Custom dev server command").option("--port <port>", "Dev server port").action(previewCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qlucent/fishi",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "FISHI — Your AI Dev Team That Actually Ships. Autonomous agent framework for Claude Code.",
   "license": "MIT",
   "type": "module",