@aweeclaw/scenario-cli 1.0.0

package/dist/bin.js

@@ -0,0 +1,980 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/utils/helpers.ts
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+
+// src/utils/types.ts
+import { z } from "zod";
+var DeclarativeToolParamSchema = z.lazy(
+  () => z.object({
+    type: z.enum(["string", "number", "boolean", "array", "object"]),
+    description: z.string(),
+    required: z.boolean().optional(),
+    default: z.unknown().optional(),
+    enum: z.array(z.string()).optional(),
+    items: DeclarativeToolParamSchema.optional(),
+    properties: z.record(DeclarativeToolParamSchema).optional()
+  })
+);
+var DeclarativeCustomToolSchema = z.object({
+  name: z.string().min(1),
+  description: z.string(),
+  parameters: z.record(DeclarativeToolParamSchema),
+  executor: z.enum(["sql_query", "run_command", "read_file", "write_file", "web_search", "read_url"]),
+  template: z.string().optional(),
+  postProcess: z.enum(["json", "table", "text", "markdown"]).optional()
+});
+var DeclarativeIdentitySchema = z.object({
+  systemPrompt: z.string().optional(),
+  systemPromptFile: z.string().optional(),
+  securityRules: z.string().optional(),
+  securityRulesFile: z.string().optional(),
+  conventions: z.string().optional(),
+  conventionsFile: z.string().optional(),
+  workflow: z.string().optional(),
+  workflowFile: z.string().optional(),
+  outputFormat: z.string().optional(),
+  toolGuidelines: z.string().optional()
+});
+var DeclarativeUISchema = z.object({
+  layout: z.enum(["chat-centric", "split", "editor-centric", "custom"]).optional(),
+  panels: z.array(z.string()).optional(),
+  sidebarItems: z.array(z.object({
+    id: z.string(),
+    icon: z.string(),
+    label: z.string(),
+    labelZh: z.string(),
+    component: z.string(),
+    position: z.number().optional()
+  })).optional(),
+  welcomeComponent: z.string().optional()
+});
+var DeclarativeDatabaseSchema = z.object({
+  installScriptFiles: z.array(z.string()).optional(),
+  uninstallScriptFiles: z.array(z.string()).optional(),
+  installScripts: z.array(z.object({
+    id: z.string(),
+    description: z.string().optional(),
+    sql: z.string()
+  })).optional(),
+  uninstallScripts: z.array(z.object({
+    id: z.string(),
+    description: z.string().optional(),
+    sql: z.string()
+  })).optional()
+});
+var DeclarativeCapabilitiesSchema = z.object({
+  builtinTools: z.array(z.string()).optional(),
+  customTools: z.array(DeclarativeCustomToolSchema).optional(),
+  modes: z.array(z.object({
+    id: z.string(),
+    label: z.string(),
+    labelZh: z.string(),
+    icon: z.string(),
+    description: z.string(),
+    descriptionZh: z.string(),
+    toolPolicy: z.object({
+      enabled: z.boolean(),
+      requireApproval: z.boolean().optional()
+    })
+  })).optional(),
+  contextTypes: z.array(z.object({
+    type: z.string(),
+    label: z.string(),
+    labelZh: z.string(),
+    priority: z.number()
+  })).optional(),
+  outputFormats: z.array(z.string()).optional()
+});
+var DeclarativeScriptToolSchema = z.object({
+  name: z.string().min(1),
+  description: z.string(),
+  scriptFile: z.string(),
+  parameters: z.record(DeclarativeToolParamSchema)
+});
+var DeclarativeScriptsSchema = z.object({
+  onActivate: z.string().optional(),
+  onActivateFile: z.string().optional(),
+  onDeactivate: z.string().optional(),
+  onDeactivateFile: z.string().optional(),
+  onHealthCheck: z.string().optional(),
+  onHealthCheckFile: z.string().optional(),
+  tools: z.array(DeclarativeScriptToolSchema).optional()
+});
+var ScenarioConfigSchema = z.object({
+  id: z.string().min(1).regex(/^[a-z0-9-]+$/, "Scenario ID must be lowercase alphanumeric with hyphens"),
+  version: z.string().regex(/^\d+\.\d+\.\d+/, "Version must be semver (e.g. 1.0.0)"),
+  name: z.string().min(1),
+  nameZh: z.string().min(1),
+  description: z.string().default(""),
+  descriptionZh: z.string().default(""),
+  author: z.string().default("unknown"),
+  icon: z.string().default("Package"),
+  category: z.enum([
+    "productivity",
+    "development",
+    "education",
+    "business",
+    "creative",
+    "lifestyle",
+    "health",
+    "finance",
+    "legal",
+    "custom"
+  ]).default("custom"),
+  tags: z.array(z.string()).default([]),
+  minAppVersion: z.string().optional(),
+  homepage: z.string().optional(),
+  license: z.string().default("MIT"),
+  type: z.enum(["declarative", "programmatic"]).default("programmatic"),
+  entryPoint: z.string().default("src/index.ts"),
+  permissions: z.array(z.string()).default([]),
+  sharedDeps: z.record(z.string()).optional(),
+  dependencies: z.array(z.object({
+    id: z.string(),
+    versionRange: z.string().optional(),
+    required: z.boolean().default(true)
+  })).default([]),
+  identity: DeclarativeIdentitySchema.optional(),
+  capabilities: DeclarativeCapabilitiesSchema.optional(),
+  ui: DeclarativeUISchema.optional(),
+  database: DeclarativeDatabaseSchema.optional(),
+  scripts: DeclarativeScriptsSchema.optional(),
+  source: z.string().optional(),
+  hasSettings: z.boolean().optional(),
+  requiresWorkspace: z.boolean().optional()
+});
+var SHARED_EXTERNALS = [
+  "react",
+  "react-dom",
+  "react-dom/client",
+  "react/jsx-runtime",
+  "zustand",
+  "lucide-react"
+];
+var SHARED_GLOBALS = {
+  "react": "__AWEECLAW_SHARED__.modules.react",
+  "react-dom": "__AWEECLAW_SHARED__.modules.reactDom",
+  "react-dom/client": "__AWEECLAW_SHARED__.modules.reactDom",
+  "react/jsx-runtime": "__AWEECLAW_SHARED__.modules.jsxRuntime",
+  "zustand": "__AWEECLAW_SHARED__.modules.zustand",
+  "lucide-react": "__AWEECLAW_SHARED__.modules.lucideReact"
+};
+var DEFAULT_SHARED_DEPS = {
+  react: "^18.3.0",
+  "react-dom": "^18.3.0",
+  zustand: "^5.0.0",
+  "lucide-react": "^0.562.0"
+};
+
+// src/utils/helpers.ts
+function readScenarioConfig(dir) {
+  const configPath = path.join(dir, "scenario.json");
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`scenario.json not found in ${dir}`);
+  }
+  const raw = fs.readFileSync(configPath, "utf-8");
+  const json = JSON.parse(raw);
+  const parsed = ScenarioConfigSchema.safeParse(json);
+  if (!parsed.success) {
+    const errors = parsed.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`Invalid scenario.json:
+${errors}`);
+  }
+  return parsed.data;
+}
+function writeJson(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function computeDirectoryChecksum(dir) {
+  const hash = crypto.createHash("sha256");
+  const files = listFiles(dir).filter((f) => !f.endsWith("manifest.json")).sort();
+  for (const file of files) {
+    const rel = path.relative(dir, file);
+    hash.update(rel);
+    hash.update(fs.readFileSync(file));
+  }
+  return hash.digest("hex");
+}
+function listFiles(dir) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...listFiles(fullPath));
+    } else {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function buildManifest(config, checksum) {
+  return {
+    id: config.id,
+    version: config.version,
+    name: config.name,
+    nameZh: config.nameZh,
+    description: config.description,
+    descriptionZh: config.descriptionZh,
+    author: config.author,
+    icon: config.icon,
+    category: config.category,
+    tags: config.tags,
+    minAppVersion: config.minAppVersion,
+    homepage: config.homepage,
+    license: config.license,
+    type: config.type,
+    bundleEntry: config.type === "programmatic" ? "bundle/index.js" : void 0,
+    sharedDeps: config.sharedDeps ? Object.keys(config.sharedDeps) : void 0,
+    apiVersion: "1.0.0",
+    checksum,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// src/commands/init.ts
+function initScenario(cwd, options) {
+  const scenarioId = options.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (!scenarioId) {
+    throw new Error("Invalid scenario name: must produce a non-empty ID");
+  }
+  const scenarioDir = path2.join(cwd, scenarioId);
+  if (fs2.existsSync(scenarioDir)) {
+    throw new Error(`Directory "${scenarioId}" already exists`);
+  }
+  ensureDir(scenarioDir);
+  const scenarioType = options.type || "programmatic";
+  const config = {
+    id: scenarioId,
+    version: "1.0.0",
+    name: options.name,
+    nameZh: options.nameZh || options.name,
+    description: "",
+    descriptionZh: "",
+    author: options.author || "unknown",
+    icon: "Package",
+    category: options.category || "custom",
+    tags: [],
+    license: "MIT",
+    type: scenarioType,
+    entryPoint: scenarioType === "programmatic" ? "src/index.ts" : void 0,
+    permissions: [],
+    sharedDeps: scenarioType === "programmatic" ? DEFAULT_SHARED_DEPS : void 0,
+    dependencies: []
+  };
+  if (scenarioType === "declarative") {
+    config.identity = {
+      systemPromptFile: "prompts/system.md",
+      workflowFile: "prompts/workflow.md"
+    };
+    config.capabilities = {
+      builtinTools: ["web_search", "ask_user", "remember"]
+    };
+    config.ui = {
+      layout: "chat-centric"
+    };
+    config.database = {
+      installScriptFiles: [],
+      uninstallScriptFiles: []
+    };
+    config.scripts = {
+      onActivateFile: "scripts/onActivate.js",
+      onDeactivateFile: "scripts/onDeactivate.js"
+    };
+  }
+  writeJson(path2.join(scenarioDir, "scenario.json"), config);
+  if (scenarioType === "programmatic") {
+    writeProgrammaticTemplate(scenarioDir, config);
+  } else {
+    writeDeclarativeTemplate(scenarioDir, config);
+  }
+  const packageJson = {
+    name: `@aweeclaw/scenario-${scenarioId}`,
+    version: config.version,
+    private: true,
+    type: "module",
+    scripts: {
+      build: "aweeclaw-scenario build",
+      pack: "aweeclaw-scenario pack",
+      dev: "aweeclaw-scenario dev",
+      validate: "aweeclaw-scenario validate"
+    }
+  };
+  if (scenarioType === "programmatic") {
+    packageJson.devDependencies = {
+      "@aweeclaw/scenario-sdk": "^1.0.0",
+      "@types/react": "^18.3.0",
+      typescript: "^5.3.0"
+    };
+  } else {
+    packageJson.devDependencies = {
+      "@aweeclaw/scenario-sdk": "^1.0.0"
+    };
+  }
+  writeJson(path2.join(scenarioDir, "package.json"), packageJson);
+  if (scenarioType === "programmatic") {
+    writeTsConfig(scenarioDir);
+  }
+  console.log(`\u2705 Scenario "${scenarioId}" initialized at ${scenarioDir}`);
+  console.log(`
+  cd ${scenarioId}`);
+  console.log(`  npm install`);
+  if (scenarioType === "programmatic") {
+    console.log(`  aweeclaw-scenario dev`);
+  } else {
+    console.log(`  # Edit scenario.json and prompts/ files`);
+    console.log(`  aweeclaw-scenario build`);
+  }
+  console.log();
+}
+function writeProgrammaticTemplate(dir, config) {
+  const srcDir = path2.join(dir, "src");
+  const componentsDir = path2.join(srcDir, "components");
+  ensureDir(componentsDir);
+  fs2.writeFileSync(
+    path2.join(srcDir, "index.ts"),
+    `import type { ScenarioModule, ScenarioModuleContext, ScenarioToolDefinition } from '@aweeclaw/scenario-sdk'
+import { DashboardPanel } from './components/DashboardPanel.js'
+
+export default {
+  id: '${config.id}',
+  version: '${config.version}',
+
+  getManifest() {
+    return {
+      id: '${config.id}',
+      version: '${config.version}',
+      name: '${config.name}',
+      nameZh: '${config.nameZh}',
+      description: '${config.description}',
+      descriptionZh: '${config.descriptionZh}',
+      author: '${config.author}',
+      icon: '${config.icon}',
+      category: '${config.category}',
+      tags: ${JSON.stringify(config.tags)},
+      entryPoint: 'bundle/index.js',
+    }
+  },
+
+  getPlugin() {
+    return {
+      id: '${config.id}',
+      name: '${config.name}',
+      nameZh: '${config.nameZh}',
+      icon: '${config.icon}',
+      description: '${config.description}',
+      descriptionZh: '${config.descriptionZh}',
+      version: '${config.version}',
+      author: '${config.author}',
+      category: '${config.category}',
+      tags: ${JSON.stringify(config.tags)},
+      identity: { systemPrompt: '', securityRules: '', conventions: '', workflow: '' },
+      capabilities: { toolPacks: [], modes: [], contextTypes: [], outputFormats: [] },
+      ui: { layout: 'chat-centric', panels: [], sidebarItems: [], statusBarItems: [] },
+      dataSources: { workspace: false },
+    }
+  },
+
+  getTools(): ScenarioToolDefinition[] {
+    return []
+  },
+
+  getComponents() {
+    return {
+      DashboardPanel,
+    }
+  },
+
+  async onActivate(context: ScenarioModuleContext): Promise<void> {
+    context.publishData('scenario:activated', {
+      scenarioId: '${config.id}',
+      version: '${config.version}',
+      type: 'programmatic',
+    })
+  },
+
+  async onDeactivate(context: ScenarioModuleContext): Promise<void> {
+    context.publishData('scenario:deactivated', { scenarioId: '${config.id}' })
+  },
+
+  async onHealthCheck() {
+    return [{ name: 'module', status: 'healthy' as const, message: '${config.name} is running' }]
+  },
+} satisfies ScenarioModule
+`,
+    "utf-8"
+  );
+  fs2.writeFileSync(
+    path2.join(componentsDir, "DashboardPanel.tsx"),
+    `export function DashboardPanel() {
+  return (
+    <div style={{ padding: 16 }}>
+      <h2 style={{ fontSize: 16, fontWeight: 600, marginBottom: 8 }}>
+        ${config.name}
+      </h2>
+      <p style={{ fontSize: 13, opacity: 0.7 }}>
+        This is the dashboard panel for ${config.name} scenario.
+        Customize this component to build your scenario UI.
+      </p>
+    </div>
+  )
+}
+`,
+    "utf-8"
+  );
+  const promptsDir = path2.join(dir, "prompts");
+  ensureDir(promptsDir);
+  fs2.writeFileSync(
+    path2.join(promptsDir, "system.md"),
+    `You are the ${config.name} scenario assistant.
+Help users with ${config.category} related tasks.
+`,
+    "utf-8"
+  );
+}
+function writeDeclarativeTemplate(dir, config) {
+  const promptsDir = path2.join(dir, "prompts");
+  ensureDir(promptsDir);
+  fs2.writeFileSync(
+    path2.join(promptsDir, "system.md"),
+    `You are the ${config.name} scenario assistant.
+
+Your role is to help users with ${config.category} related tasks.
+Be professional, accurate, and helpful.
+`,
+    "utf-8"
+  );
+  fs2.writeFileSync(
+    path2.join(promptsDir, "workflow.md"),
+    `## Workflow
+
+1. Understand user request
+2. Process and respond
+3. Offer follow-up suggestions
+`,
+    "utf-8"
+  );
+  const scriptsDir = path2.join(dir, "scripts");
+  ensureDir(scriptsDir);
+  fs2.writeFileSync(
+    path2.join(scriptsDir, "onActivate.js"),
+    `// This script runs when the scenario is activated
+// Available globals: console, fetch, JSON
+console.log('${config.name} activated')
+`,
+    "utf-8"
+  );
+  fs2.writeFileSync(
+    path2.join(scriptsDir, "onDeactivate.js"),
+    `// This script runs when the scenario is deactivated
+console.log('${config.name} deactivated')
+`,
+    "utf-8"
+  );
+  const dbDir = path2.join(dir, "db");
+  ensureDir(dbDir);
+  fs2.writeFileSync(
+    path2.join(dbDir, "install.sql"),
+    `-- Database install script for ${config.name}
+-- Add your table creation statements here
+`,
+    "utf-8"
+  );
+  fs2.writeFileSync(
+    path2.join(dbDir, "uninstall.sql"),
+    `-- Database uninstall script for ${config.name}
+-- Add your table drop statements here
+`,
+    "utf-8"
+  );
+}
+function writeTsConfig(dir) {
+  writeJson(path2.join(dir, "tsconfig.json"), {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      jsx: "react-jsx",
+      outDir: "dist",
+      rootDir: "src",
+      types: ["node"],
+      paths: {
+        "@aweeclaw/scenario-sdk": ["./node_modules/@aweeclaw/scenario-sdk"]
+      }
+    },
+    include: ["src"],
+    exclude: ["node_modules", "dist"]
+  });
+}
+
+// src/commands/build.ts
+import fs3 from "fs";
+import path3 from "path";
+import { build } from "vite";
+async function buildScenario(cwd, options = {}) {
+  const config = readScenarioConfig(cwd);
+  if (config.type === "declarative") {
+    buildDeclarative(cwd, config, options);
+    return;
+  }
+  await buildProgrammatic(cwd, config, options);
+}
+async function buildProgrammatic(cwd, config, options) {
+  const outDir = path3.resolve(cwd, options.outDir || "dist");
+  const entryPoint = path3.resolve(cwd, config.entryPoint || "src/index.ts");
+  if (!fs3.existsSync(entryPoint)) {
+    throw new Error(`Entry point not found: ${entryPoint}`);
+  }
+  const sharedExternalsPlugin = {
+    name: "aweeclaw-shared-externals",
+    enforce: "pre",
+    resolveId(source) {
+      if (SHARED_EXTERNALS.includes(source)) {
+        return { id: source, external: true };
+      }
+      return null;
+    }
+  };
+  const viteConfig = {
+    root: cwd,
+    logLevel: "warn",
+    build: {
+      lib: {
+        entry: entryPoint,
+        formats: ["es"],
+        fileName: () => "bundle/index.js"
+      },
+      outDir,
+      emptyOutDir: true,
+      minify: options.minify ?? false,
+      sourcemap: options.sourcemap ?? true,
+      target: "esnext",
+      cssCodeSplit: true,
+      rollupOptions: {
+        external: SHARED_EXTERNALS,
+        output: {
+          format: "es",
+          globals: SHARED_GLOBALS,
+          paths(id) {
+            if (SHARED_GLOBALS[id]) {
+              return SHARED_GLOBALS[id];
+            }
+            return id;
+          },
+          manualChunks(id) {
+            if (id.includes("/src/components/")) {
+              const match = id.match(/\/src\/components\/(.+?)\./);
+              if (match) {
+                return match[1];
+              }
+            }
+            return void 0;
+          },
+          chunkFileNames: "bundle/[name].js",
+          assetFileNames: "bundle/[name].[ext]"
+        }
+      }
+    },
+    plugins: [sharedExternalsPlugin]
+  };
+  console.log(`\u{1F528} Building scenario "${config.id}" v${config.version}...`);
+  await build(viteConfig);
+  const configDir = path3.join(outDir, "config");
+  ensureDir(configDir);
+  writeJson(path3.join(configDir, "scenario.json"), config);
+  if (fs3.existsSync(path3.join(cwd, "prompts"))) {
+    copyDir(path3.join(cwd, "prompts"), path3.join(outDir, "prompts"));
+  }
+  if (fs3.existsSync(path3.join(cwd, "db"))) {
+    copyDir(path3.join(cwd, "db"), path3.join(outDir, "db"));
+  }
+  if (fs3.existsSync(path3.join(cwd, "assets"))) {
+    copyDir(path3.join(cwd, "assets"), path3.join(outDir, "assets"));
+  }
+  const checksum = computeDirectoryChecksum(outDir);
+  const manifest = buildManifest(config, checksum);
+  writeJson(path3.join(outDir, "manifest.json"), manifest);
+  console.log(`\u2705 Build complete: ${outDir}`);
+  console.log(`   Checksum: ${checksum.substring(0, 16)}...`);
+}
+function buildDeclarative(cwd, config, options) {
+  const outDir = path3.resolve(cwd, options.outDir || "dist");
+  ensureDir(outDir);
+  const configDir = path3.join(outDir, "config");
+  ensureDir(configDir);
+  writeJson(path3.join(configDir, "scenario.json"), config);
+  if (fs3.existsSync(path3.join(cwd, "prompts"))) {
+    copyDir(path3.join(cwd, "prompts"), path3.join(outDir, "prompts"));
+  }
+  if (fs3.existsSync(path3.join(cwd, "scripts"))) {
+    copyDir(path3.join(cwd, "scripts"), path3.join(outDir, "scripts"));
+  }
+  if (fs3.existsSync(path3.join(cwd, "db"))) {
+    copyDir(path3.join(cwd, "db"), path3.join(outDir, "db"));
+  }
+  if (fs3.existsSync(path3.join(cwd, "assets"))) {
+    copyDir(path3.join(cwd, "assets"), path3.join(outDir, "assets"));
+  }
+  const checksum = computeDirectoryChecksum(outDir);
+  const manifest = buildManifest(config, checksum);
+  writeJson(path3.join(outDir, "manifest.json"), manifest);
+  console.log(`\u2705 Declarative scenario packaged: ${outDir}`);
+}
+function copyDir(src, dest) {
+  if (!fs3.existsSync(src)) return;
+  ensureDir(dest);
+  const entries = fs3.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path3.join(src, entry.name);
+    const destPath = path3.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs3.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/commands/pack.ts
+import fs4 from "fs";
+import path4 from "path";
+import { create as createTar } from "tar";
+async function packScenario(cwd, options = {}) {
+  const distDir = path4.resolve(cwd, "dist");
+  if (!fs4.existsSync(distDir)) {
+    throw new Error('dist/ directory not found. Run "aweeclaw-scenario build" first.');
+  }
+  const config = readScenarioConfig(cwd);
+  const checksum = computeDirectoryChecksum(distDir);
+  const manifest = buildManifest(config, checksum);
+  writeJson(path4.join(distDir, "manifest.json"), manifest);
+  const outDir = path4.resolve(cwd, options.outDir || ".");
+  const fileName = `${config.id}-${config.version}.tar.gz`;
+  const outputPath = path4.join(outDir, fileName);
+  if (!fs4.existsSync(outDir)) {
+    fs4.mkdirSync(outDir, { recursive: true });
+  }
+  if (fs4.existsSync(outputPath)) {
+    fs4.unlinkSync(outputPath);
+  }
+  await createTar(
+    {
+      gzip: true,
+      file: outputPath,
+      cwd: distDir,
+      portable: true
+    },
+    fs4.readdirSync(distDir)
+  );
+  const stats = fs4.statSync(outputPath);
+  const sizeKB = (stats.size / 1024).toFixed(1);
+  console.log(`\u{1F4E6} Packed: ${outputPath}`);
+  console.log(`   Size: ${sizeKB} KB`);
+  console.log(`   Checksum: ${checksum.substring(0, 16)}...`);
+  return outputPath;
+}
+
+// src/commands/dev.ts
+import fs5 from "fs";
+import path5 from "path";
+import { createServer } from "vite";
+async function devScenario(cwd, options = {}) {
+  const config = readScenarioConfig(cwd);
+  if (config.type === "declarative") {
+    console.log("\u2139\uFE0F  Declarative scenarios do not require a dev server.");
+    console.log('   Edit prompts/ and scenario.json directly, then run "aweeclaw-scenario build".');
+    return;
+  }
+  const entryPoint = path5.resolve(cwd, config.entryPoint || "src/index.ts");
+  if (!fs5.existsSync(entryPoint)) {
+    throw new Error(`Entry point not found: ${entryPoint}`);
+  }
+  const port = options.port || 3210;
+  const server = await createServer({
+    root: cwd,
+    logLevel: "info",
+    server: {
+      port,
+      strictPort: false
+    },
+    resolve: {
+      alias: {
+        "@aweeclaw/scenario-sdk": path5.resolve(cwd, "node_modules/@aweeclaw/scenario-sdk")
+      }
+    },
+    build: {
+      target: "esnext"
+    },
+    define: {
+      "__AWEECLAW_SHARED__": "window.__AWEECLAW_SHARED__"
+    }
+  });
+  await server.listen();
+  console.log(`
+\u{1F680} Dev server for "${config.id}" running at:`);
+  console.log(`   ${server.resolvedUrls?.local?.[0] || `http://localhost:${port}`}`);
+  console.log(`
+   Edit src/ files and changes will hot-reload.`);
+  console.log(`   Press Ctrl+C to stop.
+`);
+}
+
+// src/commands/validate.ts
+import fs6 from "fs";
+import path6 from "path";
+async function validateScenario(cwd, options = {}) {
+  const errors = [];
+  const warnings = [];
+  console.log(`\u{1F50D} Validating scenario in ${cwd}...
+`);
+  let config = null;
+  try {
+    config = readScenarioConfig(cwd);
+    console.log(`  \u2713 scenario.json is valid (id: ${config.id}, v${config.version})`);
+  } catch (err) {
+    errors.push(err instanceof Error ? err.message : String(err));
+    printResults(errors, warnings);
+    return false;
+  }
+  const distDir = path6.resolve(cwd, "dist");
+  if (!fs6.existsSync(distDir)) {
+    errors.push('dist/ directory not found. Run "aweeclaw-scenario build" first.');
+    printResults(errors, warnings);
+    return false;
+  }
+  const manifestPath = path6.join(distDir, "manifest.json");
+  if (!fs6.existsSync(manifestPath)) {
+    errors.push("manifest.json not found in dist/");
+  } else {
+    try {
+      const manifest = JSON.parse(fs6.readFileSync(manifestPath, "utf-8"));
+      if (!manifest.id) errors.push('manifest.json missing "id"');
+      if (!manifest.version) errors.push('manifest.json missing "version"');
+      if (!manifest.type) errors.push('manifest.json missing "type"');
+      if (!manifest.checksum) errors.push('manifest.json missing "checksum"');
+      console.log("  \u2713 manifest.json is valid");
+    } catch {
+      errors.push("manifest.json is not valid JSON");
+    }
+  }
+  if (config.type === "programmatic") {
+    validateProgrammatic(distDir, config, errors, warnings, options.strict);
+  }
+  if (config.type === "declarative") {
+    validateDeclarative(distDir, config, errors, warnings);
+  }
+  if (fs6.existsSync(manifestPath)) {
+    const checksum = computeDirectoryChecksum(distDir);
+    const manifest = JSON.parse(fs6.readFileSync(manifestPath, "utf-8"));
+    if (manifest.checksum === checksum) {
+      console.log("  \u2713 Checksum matches");
+    } else {
+      errors.push(`Checksum mismatch: manifest has "${manifest.checksum?.substring(0, 16)}...", actual is "${checksum.substring(0, 16)}..."`);
+    }
+  }
+  const files = listFiles(distDir);
+  const totalSize = files.reduce((sum, f) => sum + fs6.statSync(f).size, 0);
+  const sizeMB = (totalSize / 1024 / 1024).toFixed(2);
+  console.log(`  \u2713 Total size: ${sizeMB} MB (${files.length} files)`);
+  if (totalSize > 50 * 1024 * 1024) {
+    warnings.push(`Package size (${sizeMB} MB) exceeds 50 MB limit`);
+  }
+  printResults(errors, warnings);
+  return errors.length === 0;
+}
+function validateProgrammatic(distDir, config, errors, warnings, strict) {
+  const bundleEntry = path6.join(distDir, "bundle", "index.js");
+  if (!fs6.existsSync(bundleEntry)) {
+    errors.push("bundle/index.js not found (required for programmatic scenarios)");
+    return;
+  }
+  const content = fs6.readFileSync(bundleEntry, "utf-8");
+  for (const ext of SHARED_EXTERNALS) {
+    const importPattern = new RegExp(`import.*from\\s+['"]${ext.replace("/", "\\/")}['"]`);
+    const requirePattern = new RegExp(`require\\(['"]${ext.replace("/", "\\/")}['"]\\)`);
+    if (importPattern.test(content) || requirePattern.test(content)) {
+      console.log(`  \u2713 Shared dependency "${ext}" is externalized`);
+    }
+  }
+  if (content.includes("__AWEECLAW_SHARED__")) {
+    console.log("  \u2713 Uses __AWEECLAW_SHARED__ for shared dependencies");
+  } else if (strict) {
+    warnings.push("Bundle does not reference __AWEECLAW_SHARED__. Ensure shared deps are externalized.");
+  }
+}
+function validateDeclarative(distDir, config, errors, warnings) {
+  const configDir = path6.join(distDir, "config");
+  const distConfigPath = path6.join(configDir, "scenario.json");
+  if (!fs6.existsSync(distConfigPath)) {
+    errors.push("config/scenario.json not found in dist/");
+  }
+  const promptsDir = path6.join(distDir, "prompts");
+  if (!fs6.existsSync(promptsDir)) {
+    warnings.push("prompts/ directory not found (recommended for declarative scenarios)");
+  } else {
+    const systemMd = path6.join(promptsDir, "system.md");
+    if (!fs6.existsSync(systemMd)) {
+      if (config.identity?.systemPromptFile) {
+        errors.push(`prompts/system.md not found (referenced by identity.systemPromptFile)`);
+      } else {
+        warnings.push("prompts/system.md not found (recommended for declarative scenarios)");
+      }
+    } else {
+      console.log("  \u2713 prompts/system.md exists");
+    }
+  }
+  if (config.identity) {
+    const fileRefs = [
+      { key: "systemPromptFile", path: config.identity.systemPromptFile },
+      { key: "securityRulesFile", path: config.identity.securityRulesFile },
+      { key: "conventionsFile", path: config.identity.conventionsFile },
+      { key: "workflowFile", path: config.identity.workflowFile }
+    ];
+    for (const ref of fileRefs) {
+      if (ref.path && !fs6.existsSync(path6.join(distDir, ref.path))) {
+        errors.push(`identity.${ref.key} references "${ref.path}" but file not found in dist/`);
+      }
+    }
+  }
+  if (config.database) {
+    const scriptRefs = [
+      { key: "installScriptFiles", paths: config.database.installScriptFiles },
+      { key: "uninstallScriptFiles", paths: config.database.uninstallScriptFiles }
+    ];
+    for (const ref of scriptRefs) {
+      if (ref.paths) {
+        for (const scriptPath of ref.paths) {
+          if (!fs6.existsSync(path6.join(distDir, scriptPath))) {
+            errors.push(`database.${ref.key} references "${scriptPath}" but file not found in dist/`);
+          }
+        }
+      }
+    }
+  }
+  if (config.scripts) {
+    const scriptRefs = [
+      { key: "onActivateFile", path: config.scripts.onActivateFile },
+      { key: "onDeactivateFile", path: config.scripts.onDeactivateFile },
+      { key: "onHealthCheckFile", path: config.scripts.onHealthCheckFile }
+    ];
+    for (const ref of scriptRefs) {
+      if (ref.path && !fs6.existsSync(path6.join(distDir, ref.path))) {
+        errors.push(`scripts.${ref.key} references "${ref.path}" but file not found in dist/`);
+      }
+    }
+    if (config.scripts.tools) {
+      for (const tool of config.scripts.tools) {
+        if (tool.scriptFile && !fs6.existsSync(path6.join(distDir, tool.scriptFile))) {
+          errors.push(`scripts.tools[${tool.name}].scriptFile references "${tool.scriptFile}" but file not found in dist/`);
+        }
+      }
+    }
+  }
+  if (config.capabilities?.customTools) {
+    for (const tool of config.capabilities.customTools) {
+      if (!tool.name) errors.push(`capabilities.customTools: tool missing "name"`);
+      if (!tool.executor) errors.push(`capabilities.customTools[${tool.name}]: tool missing "executor"`);
+    }
+  }
+  console.log("  \u2713 Declarative scenario structure validated");
+}
+function printResults(errors, warnings) {
+  console.log();
+  if (warnings.length > 0) {
+    console.log("\u26A0\uFE0F  Warnings:");
+    for (const w of warnings) {
+      console.log(`   - ${w}`);
+    }
+    console.log();
+  }
+  if (errors.length > 0) {
+    console.log("\u274C Errors:");
+    for (const e of errors) {
+      console.log(`   - ${e}`);
+    }
+    console.log();
+    console.log("Validation failed.");
+  } else {
+    console.log("\u2705 Validation passed!");
+  }
+}
+
+// src/bin.ts
+var program = new Command();
+program.name("aweeclaw-scenario").description("CLI tool for building, packing, and managing Aweeclaw scenarios").version("1.0.0");
+program.command("init").description("Initialize a new scenario project").argument("<name>", "Scenario name (e.g. my-scenario)").option("--name-zh <nameZh>", "Chinese name for the scenario").option("--category <category>", "Scenario category", "custom").option("--type <type>", "Scenario type: declarative or programmatic", "programmatic").option("--author <author>", "Author name").action((name, opts) => {
+  try {
+    initScenario(process.cwd(), {
+      name,
+      nameZh: opts.nameZh,
+      category: opts.category,
+      type: opts.type,
+      author: opts.author
+    });
+  } catch (err) {
+    console.error("\u274C Init failed:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.command("build").description("Build the scenario into dist/").option("--out-dir <dir>", "Output directory", "dist").option("--minify", "Minify output", false).option("--no-sourcemap", "Disable sourcemap").action(async (opts) => {
+  try {
+    await buildScenario(process.cwd(), {
+      outDir: opts.outDir,
+      minify: opts.minify,
+      sourcemap: opts.sourcemap
+    });
+  } catch (err) {
+    console.error("\u274C Build failed:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.command("pack").description("Pack dist/ into a tar.gz archive").option("--out-dir <dir>", "Output directory for the archive", ".").action(async (opts) => {
+  try {
+    await packScenario(process.cwd(), { outDir: opts.outDir });
+  } catch (err) {
+    console.error("\u274C Pack failed:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.command("dev").description("Start local development server with hot reload").option("--port <port>", "Dev server port", "3210").action(async (opts) => {
+  try {
+    await devScenario(process.cwd(), { port: parseInt(opts.port, 10) });
+  } catch (err) {
+    console.error("\u274C Dev server failed:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.command("validate").description("Validate the built scenario package").option("--strict", "Enable strict validation", false).action(async (opts) => {
+  try {
+    const valid = await validateScenario(process.cwd(), { strict: opts.strict });
+    process.exit(valid ? 0 : 1);
+  } catch (err) {
+    console.error("\u274C Validation failed:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=bin.js.map