@smooai/config 2.0.0

package/dist/cli.mjs

@@ -0,0 +1,1562 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli/components/Banner.tsx
+import { Box, Text } from "ink";
+import BigText from "ink-big-text";
+import Gradient from "ink-gradient";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Banner({ title }) {
+  return /* @__PURE__ */ jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Gradient, { colors: ["#f49f0a", "#ff6b6c"], children: /* @__PURE__ */ jsx(BigText, { text: "Smoo AI", font: "tiny" }) }),
+    /* @__PURE__ */ jsx(Text, { bold: true, children: title })
+  ] });
+}
+var init_Banner = __esm({
+  "src/cli/components/Banner.tsx"() {
+    "use strict";
+  }
+});
+
+// src/cli/components/TaskList.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import Spinner from "ink-spinner";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function TaskList({ tasks }) {
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: tasks.map((task, i) => /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Box2, { width: 3, children: [
+      task.status === "running" && /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: /* @__PURE__ */ jsx2(Spinner, { type: "dots" }) }),
+      task.status === "done" && /* @__PURE__ */ jsx2(Text2, { color: "green", children: "\u2713" }),
+      task.status === "error" && /* @__PURE__ */ jsx2(Text2, { color: "red", children: "\u2717" }),
+      task.status === "pending" && /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "\u25CB" })
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { color: task.status === "error" ? "red" : task.status === "done" ? "green" : void 0, children: task.label }),
+    task.error && /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+      " \u2014 ",
+      task.error
+    ] })
+  ] }, i)) });
+}
+var init_TaskList = __esm({
+  "src/cli/components/TaskList.tsx"() {
+    "use strict";
+  }
+});
+
+// src/cli/utils/output.ts
+function isInteractive(jsonFlag) {
+  if (jsonFlag) return false;
+  return Boolean(process.stdout.isTTY);
+}
+function jsonOutput(data, exitCode = 0) {
+  console.log(JSON.stringify(data, null, 2));
+  process.exit(exitCode);
+}
+var init_output = __esm({
+  "src/cli/utils/output.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/commands/init.tsx
+var init_exports = {};
+__export(init_exports, {
+  initLogic: () => initLogic,
+  runInit: () => runInit
+});
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from "fs";
+import { join } from "path";
+import { render, Box as Box3, Text as Text3 } from "ink";
+import { useEffect, useState } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+async function initLogic(options) {
+  const configDir = join(process.cwd(), ".smooai-config");
+  const filesCreated = [];
+  const language = options.language ?? "typescript";
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+    filesCreated.push(".smooai-config/");
+  }
+  switch (language) {
+    case "typescript": {
+      const defaultPath = join(configDir, "default.ts");
+      if (!existsSync(defaultPath)) {
+        writeFileSync(defaultPath, TS_DEFAULT_CONFIG);
+        filesCreated.push(".smooai-config/default.ts");
+      }
+      const devPath = join(configDir, "development.ts");
+      if (!existsSync(devPath)) {
+        writeFileSync(devPath, TS_ENV_CONFIG);
+        filesCreated.push(".smooai-config/development.ts");
+      }
+      break;
+    }
+    case "python": {
+      const genPath = join(configDir, "schema_gen.py");
+      if (!existsSync(genPath)) {
+        writeFileSync(genPath, PYTHON_SCHEMA_GEN);
+        filesCreated.push(".smooai-config/schema_gen.py");
+      }
+      const devPath = join(configDir, "development.json");
+      if (!existsSync(devPath)) {
+        writeFileSync(devPath, JSON_ENV_STARTER);
+        filesCreated.push(".smooai-config/development.json");
+      }
+      break;
+    }
+    case "go": {
+      const genPath = join(configDir, "main.go");
+      if (!existsSync(genPath)) {
+        writeFileSync(genPath, GO_SCHEMA_GEN);
+        filesCreated.push(".smooai-config/main.go");
+      }
+      const devPath = join(configDir, "development.json");
+      if (!existsSync(devPath)) {
+        writeFileSync(devPath, JSON_ENV_STARTER);
+        filesCreated.push(".smooai-config/development.json");
+      }
+      break;
+    }
+    case "rust": {
+      const cargoPath = join(configDir, "Cargo.toml");
+      if (!existsSync(cargoPath)) {
+        writeFileSync(cargoPath, RUST_CARGO_TOML);
+        filesCreated.push(".smooai-config/Cargo.toml");
+      }
+      const srcDir = join(configDir, "src");
+      if (!existsSync(srcDir)) {
+        mkdirSync(srcDir, { recursive: true });
+      }
+      const mainPath = join(srcDir, "main.rs");
+      if (!existsSync(mainPath)) {
+        writeFileSync(mainPath, RUST_MAIN_RS);
+        filesCreated.push(".smooai-config/src/main.rs");
+      }
+      const devPath = join(configDir, "development.json");
+      if (!existsSync(devPath)) {
+        writeFileSync(devPath, JSON_ENV_STARTER);
+        filesCreated.push(".smooai-config/development.json");
+      }
+      break;
+    }
+    default: {
+      const schemaPath = join(configDir, "schema.json");
+      if (!existsSync(schemaPath)) {
+        writeFileSync(schemaPath, JSON_SCHEMA_STARTER);
+        filesCreated.push(".smooai-config/schema.json");
+      }
+      const devPath = join(configDir, "development.json");
+      if (!existsSync(devPath)) {
+        writeFileSync(devPath, JSON_ENV_STARTER);
+        filesCreated.push(".smooai-config/development.json");
+      }
+      break;
+    }
+  }
+  const gitignorePath = join(process.cwd(), ".gitignore");
+  const localPattern = ".smooai-config/local.*";
+  if (existsSync(gitignorePath)) {
+    const content = readFileSync(gitignorePath, "utf-8");
+    if (!content.includes(localPattern)) {
+      appendFileSync(gitignorePath, `
+# Smoo AI local config
+${localPattern}
+`);
+      filesCreated.push(".gitignore (updated)");
+    }
+  }
+  return { success: true, filesCreated };
+}
+function InitUI({ options }) {
+  const [tasks, setTasks] = useState([
+    { label: "Creating .smooai-config/ directory", status: "pending" },
+    { label: "Writing config files", status: "pending" },
+    { label: "Updating .gitignore", status: "pending" }
+  ]);
+  const [result, setResult] = useState(null);
+  useEffect(() => {
+    (async () => {
+      setTasks((t) => t.map((task, i) => i === 0 ? { ...task, status: "running" } : task));
+      try {
+        const res = await initLogic(options);
+        setTasks([
+          { label: "Creating .smooai-config/ directory", status: "done" },
+          { label: "Writing config files", status: "done" },
+          { label: "Updating .gitignore", status: "done" }
+        ]);
+        setResult(res);
+      } catch (err) {
+        setTasks(
+          (t) => t.map((task) => task.status === "running" ? { ...task, status: "error", error: err instanceof Error ? err.message : String(err) } : task)
+        );
+      }
+    })();
+  }, []);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Banner, { title: "Initialize Project" }),
+    /* @__PURE__ */ jsx3(TaskList, { tasks }),
+    result && /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "green", bold: true, children: "Project initialized!" }),
+      result.filesCreated.map((f, i) => /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+        " ",
+        "Created: ",
+        f
+      ] }, i))
+    ] })
+  ] });
+}
+function runInit(options) {
+  if (!isInteractive(options.json)) {
+    initLogic(options).then(
+      (result) => jsonOutput(result),
+      (err) => jsonOutput({ success: false, error: err.message }, 1)
+    );
+    return;
+  }
+  render(/* @__PURE__ */ jsx3(InitUI, { options }));
+}
+var TS_DEFAULT_CONFIG, TS_ENV_CONFIG, JSON_SCHEMA_STARTER, JSON_ENV_STARTER, PYTHON_SCHEMA_GEN, GO_SCHEMA_GEN, RUST_CARGO_TOML, RUST_MAIN_RS;
+var init_init = __esm({
+  "src/cli/commands/init.tsx"() {
+    "use strict";
+    init_Banner();
+    init_TaskList();
+    init_output();
+    TS_DEFAULT_CONFIG = `import { defineConfig, StringSchema, BooleanSchema, NumberSchema } from '@smooai/config';
+
+// Define your configuration schema
+export default defineConfig({
+    publicConfigSchema: {
+        // Add your public config keys here
+        // Example: apiUrl: StringSchema,
+    },
+    secretConfigSchema: {
+        // Add your secret config keys here
+        // Example: databaseUrl: StringSchema,
+    },
+    featureFlagSchema: {
+        // Add your feature flag keys here
+        // Example: enableNewFeature: BooleanSchema,
+    },
+});
+`;
+    TS_ENV_CONFIG = `// Environment-specific overrides for development
+// Import your config definition to get type-safe keys
+// import config from './config';
+
+export default {
+    // Override config values for this environment
+};
+`;
+    JSON_SCHEMA_STARTER = JSON.stringify(
+      {
+        $schema: "http://json-schema.org/draft-07/schema#",
+        type: "object",
+        properties: {
+          public: {
+            type: "object",
+            properties: {},
+            description: "Public configuration values"
+          },
+          secret: {
+            type: "object",
+            properties: {},
+            description: "Secret configuration values"
+          },
+          featureFlags: {
+            type: "object",
+            properties: {},
+            description: "Feature flag values"
+          }
+        }
+      },
+      null,
+      2
+    );
+    JSON_ENV_STARTER = JSON.stringify(
+      {
+        public: {},
+        secret: {},
+        featureFlags: {}
+      },
+      null,
+      2
+    );
+    PYTHON_SCHEMA_GEN = `"""Schema generator for Smoo AI config.
+
+Run this file to generate JSON Schema output:
+    python3 schema_gen.py
+"""
+
+import json
+import sys
+
+from pydantic import BaseModel
+
+from smooai_config.schema import define_config
+
+
+class PublicConfig(BaseModel):
+    # Add your public config fields here
+    # Example: api_url: str = "https://api.example.com"
+    pass
+
+
+class SecretConfig(BaseModel):
+    # Add your secret config fields here
+    # Example: database_url: str
+    pass
+
+
+class FeatureFlags(BaseModel):
+    # Add your feature flag fields here
+    # Example: enable_new_feature: bool = False
+    pass
+
+
+config = define_config(
+    public=PublicConfig,
+    secret=SecretConfig,
+    feature_flags=FeatureFlags,
+)
+
+# Print JSON Schema to stdout for CLI consumption
+json.dump(config.json_schema, sys.stdout, indent=2)
+`;
+    GO_SCHEMA_GEN = [
+      "// Schema generator for Smoo AI config.",
+      "//",
+      "// Run this file to generate JSON Schema output:",
+      "//     go run main.go",
+      "package main",
+      "",
+      "import (",
+      '	"encoding/json"',
+      '	"fmt"',
+      '	"log"',
+      "",
+      '	config "github.com/SmooAI/config/go/config"',
+      ")",
+      "",
+      "// PublicConfig defines public configuration values.",
+      "type PublicConfig struct {",
+      "	// Add your public config fields here",
+      '	// Example: APIUrl string `json:"api_url"`',
+      "}",
+      "",
+      "// SecretConfig defines secret configuration values.",
+      "type SecretConfig struct {",
+      "	// Add your secret config fields here",
+      "}",
+      "",
+      "// FeatureFlags defines feature flag values.",
+      "type FeatureFlags struct {",
+      "	// Add your feature flag fields here",
+      "}",
+      "",
+      "func main() {",
+      "	result, err := config.DefineConfigTyped(&PublicConfig{}, &SecretConfig{}, &FeatureFlags{})",
+      "	if err != nil {",
+      "		log.Fatal(err)",
+      "	}",
+      "",
+      '	data, err := json.MarshalIndent(result.JSONSchema, "", "  ")',
+      "	if err != nil {",
+      "		log.Fatal(err)",
+      "	}",
+      "	fmt.Println(string(data))",
+      "}",
+      ""
+    ].join("\n");
+    RUST_CARGO_TOML = `[package]
+name = "smooai-config-gen"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+smooai-config = "1"
+schemars = { version = "0.8", features = ["derive"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+`;
+    RUST_MAIN_RS = `//! Schema generator for Smoo AI config.
+//!
+//! Run this to generate JSON Schema output:
+//!     cargo run --manifest-path .smooai-config/Cargo.toml
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use smooai_config::schema::{define_config_typed, EmptySchema};
+
+/// Public configuration values.
+#[derive(Default, Serialize, Deserialize, JsonSchema)]
+struct PublicConfig {
+    // Add your public config fields here
+    // Example: api_url: String,
+}
+
+/// Secret configuration values.
+#[derive(Default, Serialize, Deserialize, JsonSchema)]
+struct SecretConfig {
+    // Add your secret config fields here
+}
+
+/// Feature flag values.
+#[derive(Default, Serialize, Deserialize, JsonSchema)]
+struct FeatureFlags {
+    // Add your feature flag fields here
+}
+
+fn main() {
+    let config = define_config_typed::<PublicConfig, SecretConfig, FeatureFlags>();
+    let json = serde_json::to_string_pretty(&config.json_schema).unwrap();
+    println!("{}", json);
+}
+`;
+  }
+});
+
+// src/cli/utils/api-client.ts
+var CliApiClient;
+var init_api_client = __esm({
+  "src/cli/utils/api-client.ts"() {
+    "use strict";
+    CliApiClient = class {
+      baseUrl;
+      apiKey;
+      orgId;
+      constructor(credentials) {
+        this.baseUrl = credentials.baseUrl.replace(/\/+$/, "");
+        this.apiKey = credentials.apiKey;
+        this.orgId = credentials.orgId;
+      }
+      async fetchJson(path, options) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+          ...options,
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            ...options?.headers
+          }
+        });
+        if (!response.ok) {
+          const body = await response.text().catch(() => "");
+          throw new Error(`API error: HTTP ${response.status} ${response.statusText}${body ? ` \u2014 ${body}` : ""}`);
+        }
+        return response.json();
+      }
+      async listSchemas() {
+        return this.fetchJson(`/organizations/${this.orgId}/config/schemas`);
+      }
+      async getSchema(schemaId) {
+        return this.fetchJson(`/organizations/${this.orgId}/config/schemas/${schemaId}`);
+      }
+      async createSchema(data) {
+        return this.fetchJson(`/organizations/${this.orgId}/config/schemas`, {
+          method: "POST",
+          body: JSON.stringify(data)
+        });
+      }
+      async pushSchemaVersion(schemaId, data) {
+        return this.fetchJson(`/organizations/${this.orgId}/config/schemas/${schemaId}/push`, {
+          method: "POST",
+          body: JSON.stringify(data)
+        });
+      }
+      async listEnvironments() {
+        return this.fetchJson(`/organizations/${this.orgId}/config/environments`);
+      }
+      async getAllValues(environment) {
+        const result = await this.fetchJson(
+          `/organizations/${this.orgId}/config/values?environment=${encodeURIComponent(environment)}`
+        );
+        return result.values;
+      }
+      async getValue(key, environment) {
+        const result = await this.fetchJson(
+          `/organizations/${this.orgId}/config/values/${encodeURIComponent(key)}?environment=${encodeURIComponent(environment)}`
+        );
+        return result.value;
+      }
+      async setValue(data) {
+        return this.fetchJson(`/organizations/${this.orgId}/config/values`, {
+          method: "PUT",
+          body: JSON.stringify(data)
+        });
+      }
+      async getEnvironmentByName(envName) {
+        const envs = await this.listEnvironments();
+        return envs.find((e) => e.name === envName) ?? null;
+      }
+      async getSchemaByName(name) {
+        const schemas = await this.listSchemas();
+        return schemas.find((s) => s.name === name) ?? null;
+      }
+    };
+  }
+});
+
+// src/cli/utils/credentials.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+function loadCredentials() {
+  try {
+    if (!existsSync2(CREDENTIALS_FILE)) return null;
+    const raw = readFileSync2(CREDENTIALS_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.apiKey || !parsed.orgId || !parsed.baseUrl) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(credentials) {
+  mkdirSync2(SMOOAI_DIR, { recursive: true });
+  writeFileSync2(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), { mode: 384 });
+}
+function getCredentialsOrExit() {
+  const creds = loadCredentials();
+  if (!creds) {
+    console.error("Not logged in. Run `smooai-config login` first.");
+    process.exit(1);
+  }
+  return creds;
+}
+var SMOOAI_DIR, CREDENTIALS_FILE;
+var init_credentials = __esm({
+  "src/cli/utils/credentials.ts"() {
+    "use strict";
+    SMOOAI_DIR = join2(homedir(), ".smooai");
+    CREDENTIALS_FILE = join2(SMOOAI_DIR, "credentials.json");
+  }
+});
+
+// src/cli/commands/login.tsx
+var login_exports = {};
+__export(login_exports, {
+  loginLogic: () => loginLogic,
+  runLogin: () => runLogin
+});
+import { render as render2, Box as Box4, Text as Text4 } from "ink";
+import { useEffect as useEffect2, useState as useState2 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+async function loginLogic(options) {
+  const apiKey = options.apiKey;
+  const orgId = options.orgId;
+  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+  if (!apiKey) throw new Error("API key is required. Use --api-key flag.");
+  if (!orgId) throw new Error("Organization ID is required. Use --org-id flag.");
+  const client = new CliApiClient({ apiKey, orgId, baseUrl });
+  await client.listSchemas();
+  saveCredentials({ apiKey, orgId, baseUrl });
+  return { success: true, orgId };
+}
+function LoginUI({ options }) {
+  const [tasks, setTasks] = useState2([
+    { label: "Validating credentials", status: "pending" },
+    { label: "Saving to ~/.smooai/credentials.json", status: "pending" }
+  ]);
+  const [result, setResult] = useState2(null);
+  useEffect2(() => {
+    (async () => {
+      setTasks((t) => t.map((task, i) => i === 0 ? { ...task, status: "running" } : task));
+      try {
+        const res = await loginLogic(options);
+        setTasks([
+          { label: "Validating credentials", status: "done" },
+          { label: "Saving to ~/.smooai/credentials.json", status: "done" }
+        ]);
+        setResult({ orgId: res.orgId });
+      } catch (err) {
+        setTasks(
+          (t) => t.map((task) => task.status === "running" ? { ...task, status: "error", error: err instanceof Error ? err.message : String(err) } : task)
+        );
+      }
+    })();
+  }, []);
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Banner, { title: "Login" }),
+    /* @__PURE__ */ jsx4(TaskList, { tasks }),
+    result && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { color: "green", bold: true, children: [
+      "Logged in successfully! Organization: ",
+      result.orgId
+    ] }) })
+  ] });
+}
+function runLogin(options) {
+  if (!isInteractive(options.json)) {
+    loginLogic(options).then(
+      (result) => jsonOutput(result),
+      (err) => jsonOutput({ success: false, error: err.message }, 1)
+    );
+    return;
+  }
+  render2(/* @__PURE__ */ jsx4(LoginUI, { options }));
+}
+var DEFAULT_BASE_URL;
+var init_login = __esm({
+  "src/cli/commands/login.tsx"() {
+    "use strict";
+    init_Banner();
+    init_TaskList();
+    init_api_client();
+    init_credentials();
+    init_output();
+    DEFAULT_BASE_URL = "https://api.smoo.ai";
+  }
+});
+
+// src/cli/utils/schema-loader.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+function findLocalConfigDir() {
+  let dir = process.cwd();
+  const root = "/";
+  for (let i = 0; i < 10; i++) {
+    const candidate = join3(dir, ".smooai-config");
+    if (existsSync3(candidate)) return candidate;
+    const candidate2 = join3(dir, "smooai-config");
+    if (existsSync3(candidate2)) return candidate2;
+    const parent = join3(dir, "..");
+    if (parent === dir || dir === root) break;
+    dir = parent;
+  }
+  return null;
+}
+function runGenerator(command, filePath, format) {
+  try {
+    const output = execSync(command, {
+      encoding: "utf-8",
+      timeout: 3e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return {
+      format,
+      jsonSchema: JSON.parse(output.trim()),
+      filePath
+    };
+  } catch (err) {
+    throw new Error(`Failed to run generator ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function loadLocalSchema(configDir) {
+  const dir = configDir ?? findLocalConfigDir();
+  if (!dir) return null;
+  const jsonSchemaPath = join3(dir, "schema.json");
+  if (existsSync3(jsonSchemaPath)) {
+    const raw = readFileSync3(jsonSchemaPath, "utf-8");
+    return {
+      format: "json-schema",
+      jsonSchema: JSON.parse(raw),
+      filePath: jsonSchemaPath
+    };
+  }
+  const defaultTsPath = join3(dir, "default.ts");
+  const configTsPath = join3(dir, "config.ts");
+  const tsPath = existsSync3(configTsPath) ? configTsPath : existsSync3(defaultTsPath) ? defaultTsPath : null;
+  if (tsPath) {
+    try {
+      const mod = await import(tsPath);
+      const configDef = mod.default ?? mod;
+      if (configDef.serializedAllConfigSchema) {
+        return {
+          format: "typescript",
+          jsonSchema: configDef.serializedAllConfigSchema,
+          filePath: tsPath
+        };
+      }
+    } catch (err) {
+      throw new Error(`Failed to load TypeScript config from ${tsPath}: ${err}`);
+    }
+  }
+  const pyGenPath = join3(dir, "schema_gen.py");
+  if (existsSync3(pyGenPath)) {
+    return runGenerator(`python3 "${pyGenPath}"`, pyGenPath, "python-generator");
+  }
+  const goGenPath = join3(dir, "main.go");
+  if (existsSync3(goGenPath)) {
+    return runGenerator(`go run "${goGenPath}"`, goGenPath, "go-generator");
+  }
+  const cargoPath = join3(dir, "Cargo.toml");
+  if (existsSync3(cargoPath)) {
+    return runGenerator(`cargo run --manifest-path "${cargoPath}"`, cargoPath, "rust-generator");
+  }
+  return null;
+}
+var init_schema_loader = __esm({
+  "src/cli/utils/schema-loader.ts"() {
+    "use strict";
+  }
+});
+
+// src/schema-spec/smooai-config-schema-spec.ts
+function validateSmooaiSchema(schema) {
+  const errors = [];
+  walkSchema(schema, "", errors);
+  return { valid: errors.length === 0, errors };
+}
+function walkSchema(node, path, errors) {
+  if (typeof node !== "object" || node === null || Array.isArray(node)) {
+    return;
+  }
+  const obj = node;
+  for (const key of Object.keys(obj)) {
+    if (key in REJECTED_KEYWORDS) {
+      const info = REJECTED_KEYWORDS[key];
+      errors.push({
+        path: path || "/",
+        keyword: key,
+        message: info.message,
+        suggestion: info.suggestion
+      });
+      continue;
+    }
+    if (SUPPORTED_KEYWORDS.has(key)) {
+      if (key === "format" && typeof obj[key] === "string" && !SUPPORTED_FORMATS.has(obj[key])) {
+        errors.push({
+          path: path || "/",
+          keyword: "format",
+          message: `Format "${obj[key]}" is not supported across all SDK languages.`,
+          suggestion: `Supported formats: ${[...SUPPORTED_FORMATS].join(", ")}. Use "pattern" for custom string validation.`
+        });
+      }
+      continue;
+    }
+  }
+  if (obj.properties && typeof obj.properties === "object") {
+    const props = obj.properties;
+    for (const [propName, propSchema] of Object.entries(props)) {
+      walkSchema(propSchema, `${path}/properties/${propName}`, errors);
+    }
+  }
+  if (obj.items && typeof obj.items === "object") {
+    walkSchema(obj.items, `${path}/items`, errors);
+  }
+  if (obj.additionalProperties && typeof obj.additionalProperties === "object") {
+    walkSchema(obj.additionalProperties, `${path}/additionalProperties`, errors);
+  }
+  for (const compKey of ["anyOf", "oneOf", "allOf"]) {
+    if (Array.isArray(obj[compKey])) {
+      obj[compKey].forEach((subSchema, i) => {
+        walkSchema(subSchema, `${path}/${compKey}/${i}`, errors);
+      });
+    }
+  }
+  for (const defsKey of ["$defs", "definitions"]) {
+    if (obj[defsKey] && typeof obj[defsKey] === "object") {
+      const defs = obj[defsKey];
+      for (const [defName, defSchema] of Object.entries(defs)) {
+        walkSchema(defSchema, `${path}/${defsKey}/${defName}`, errors);
+      }
+    }
+  }
+}
+var SUPPORTED_KEYWORDS, REJECTED_KEYWORDS, SUPPORTED_FORMATS;
+var init_smooai_config_schema_spec = __esm({
+  "src/schema-spec/smooai-config-schema-spec.ts"() {
+    "use strict";
+    SUPPORTED_KEYWORDS = /* @__PURE__ */ new Set([
+      // Core
+      "type",
+      "properties",
+      "required",
+      "enum",
+      "const",
+      "default",
+      // Metadata
+      "title",
+      "description",
+      "$schema",
+      // String
+      "minLength",
+      "maxLength",
+      "pattern",
+      "format",
+      // Numeric
+      "minimum",
+      "maximum",
+      "exclusiveMinimum",
+      "exclusiveMaximum",
+      "multipleOf",
+      // Array
+      "items",
+      "minItems",
+      "maxItems",
+      "uniqueItems",
+      // Object
+      "additionalProperties",
+      // Composition
+      "anyOf",
+      "oneOf",
+      "allOf",
+      // References
+      "$ref",
+      "$defs",
+      "definitions"
+    ]);
+    REJECTED_KEYWORDS = {
+      if: {
+        message: "Conditional schemas (if/then/else) are not supported across all SDK languages.",
+        suggestion: 'Use "oneOf" or "anyOf" with discriminator properties instead.'
+      },
+      then: {
+        message: "Conditional schemas (if/then/else) are not supported across all SDK languages.",
+        suggestion: 'Use "oneOf" or "anyOf" with discriminator properties instead.'
+      },
+      else: {
+        message: "Conditional schemas (if/then/else) are not supported across all SDK languages.",
+        suggestion: 'Use "oneOf" or "anyOf" with discriminator properties instead.'
+      },
+      patternProperties: {
+        message: '"patternProperties" is not supported across all SDK languages.',
+        suggestion: 'Use explicit "properties" with known key names, or "additionalProperties" with a type constraint.'
+      },
+      propertyNames: {
+        message: '"propertyNames" is not supported across all SDK languages.',
+        suggestion: "Validate property names in application code instead."
+      },
+      dependencies: {
+        message: '"dependencies" is not supported across all SDK languages.',
+        suggestion: 'Use "required" within "oneOf"/"anyOf" variants to express conditional requirements.'
+      },
+      contains: {
+        message: '"contains" is not supported across all SDK languages.',
+        suggestion: 'Use "items" with a union type ("anyOf") instead.'
+      },
+      not: {
+        message: '"not" is not supported across all SDK languages.',
+        suggestion: 'Express the constraint positively using "enum", "oneOf", or validation in application code.'
+      },
+      prefixItems: {
+        message: '"prefixItems" (tuple validation) is not supported across all SDK languages.',
+        suggestion: 'Use an "object" with named fields instead of a positional tuple.'
+      },
+      unevaluatedProperties: {
+        message: '"unevaluatedProperties" is not supported across all SDK languages.',
+        suggestion: 'Use "additionalProperties" instead.'
+      },
+      unevaluatedItems: {
+        message: '"unevaluatedItems" is not supported across all SDK languages.',
+        suggestion: 'Use "items" with a specific schema instead.'
+      }
+    };
+    SUPPORTED_FORMATS = /* @__PURE__ */ new Set(["email", "uri", "uuid", "date-time", "ipv4", "ipv6"]);
+  }
+});
+
+// src/cli/utils/schema-validator.ts
+import Ajv from "ajv";
+function validateJsonSchema(schema) {
+  try {
+    ajv.compile(schema);
+    return { valid: true };
+  } catch (err) {
+    return {
+      valid: false,
+      errors: [err instanceof Error ? err.message : String(err)]
+    };
+  }
+}
+function validateValue(schema, key, value) {
+  const properties = schema.properties;
+  if (!properties || !properties[key]) {
+    const keySchema = schema[key];
+    if (!keySchema) {
+      return { valid: true };
+    }
+    if (typeof keySchema === "string") {
+      return validatePrimitiveType(keySchema, value);
+    }
+    if (typeof keySchema === "object") {
+      return validateWithAjv(keySchema, value);
+    }
+    return { valid: true };
+  }
+  return validateWithAjv(properties[key], value);
+}
+function validatePrimitiveType(schemaType, value) {
+  switch (schemaType) {
+    case "stringSchema":
+      if (typeof value !== "string") {
+        return { valid: false, errors: [`Expected string, got ${typeof value}`] };
+      }
+      return { valid: true };
+    case "booleanSchema":
+      if (typeof value !== "boolean" && value !== "true" && value !== "false") {
+        return { valid: false, errors: [`Expected boolean, got ${typeof value}`] };
+      }
+      return { valid: true };
+    case "numberSchema":
+      if (typeof value !== "number" && isNaN(Number(value))) {
+        return { valid: false, errors: [`Expected number, got ${typeof value}`] };
+      }
+      return { valid: true };
+    default:
+      return { valid: true };
+  }
+}
+function validateWithAjv(schema, value) {
+  try {
+    const validate = ajv.compile(schema);
+    const valid = validate(value);
+    if (!valid && validate.errors) {
+      return {
+        valid: false,
+        errors: validate.errors.map((e) => `${e.instancePath || "/"} ${e.message}`)
+      };
+    }
+    return { valid: true };
+  } catch (err) {
+    return { valid: false, errors: [err instanceof Error ? err.message : String(err)] };
+  }
+}
+var ajv;
+var init_schema_validator = __esm({
+  "src/cli/utils/schema-validator.ts"() {
+    "use strict";
+    init_smooai_config_schema_spec();
+    ajv = new Ajv({ allErrors: true, strict: false });
+  }
+});
+
+// src/cli/commands/push.tsx
+var push_exports = {};
+__export(push_exports, {
+  pushLogic: () => pushLogic,
+  runPush: () => runPush
+});
+import { basename } from "path";
+import { render as render3, Box as Box5, Text as Text5 } from "ink";
+import { useEffect as useEffect3, useState as useState3 } from "react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function computeSchemaDiff(local, remote) {
+  const localKeys = new Set(Object.keys(local));
+  const remoteKeys = new Set(Object.keys(remote));
+  const added = [...localKeys].filter((k) => !remoteKeys.has(k));
+  const removed = [...remoteKeys].filter((k) => !localKeys.has(k));
+  const changed = [...localKeys].filter((k) => {
+    if (!remoteKeys.has(k)) return false;
+    return JSON.stringify(local[k]) !== JSON.stringify(remote[k]);
+  });
+  return { added, removed, changed };
+}
+async function pushLogic(options) {
+  const creds = getCredentialsOrExit();
+  const client = new CliApiClient(creds);
+  const loaded = await loadLocalSchema();
+  if (!loaded) {
+    throw new Error("No local schema found. Run `smooai-config init` first or create .smooai-config/schema.json.");
+  }
+  const validation = validateJsonSchema(loaded.jsonSchema);
+  if (!validation.valid) {
+    throw new Error(`Invalid JSON Schema: ${validation.errors?.join(", ")}`);
+  }
+  const smooaiValidation = validateSmooaiSchema(loaded.jsonSchema);
+  if (!smooaiValidation.valid) {
+    const errorMessages = smooaiValidation.errors.map((e) => `  ${e.path}: ${e.message}
+    Suggestion: ${e.suggestion}`);
+    throw new Error(`Schema uses unsupported JSON Schema features:
+${errorMessages.join("\n")}`);
+  }
+  const schemaName = options.schemaName ?? basename(process.cwd());
+  const existingSchema = await client.getSchemaByName(schemaName).catch(() => null);
+  let diff;
+  if (existingSchema) {
+    diff = computeSchemaDiff(loaded.jsonSchema, existingSchema.jsonSchema);
+    const result = await client.pushSchemaVersion(existingSchema.id, {
+      jsonSchema: loaded.jsonSchema,
+      changeDescription: options.description
+    });
+    return { success: true, schema: result.schema, version: result.version, diff };
+  }
+  const schema = await client.createSchema({
+    name: schemaName,
+    jsonSchema: loaded.jsonSchema,
+    description: options.description
+  });
+  return { success: true, schema };
+}
+function DiffDisplay({ diff }) {
+  if (diff.added.length === 0 && diff.removed.length === 0 && diff.changed.length === 0) {
+    return /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "No changes detected." });
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Schema Changes:" }),
+    diff.added.map((k) => /* @__PURE__ */ jsxs5(Text5, { color: "green", children: [
+      "+ ",
+      k
+    ] }, k)),
+    diff.removed.map((k) => /* @__PURE__ */ jsxs5(Text5, { color: "red", children: [
+      "- ",
+      k
+    ] }, k)),
+    diff.changed.map((k) => /* @__PURE__ */ jsxs5(Text5, { color: "yellow", children: [
+      "~ ",
+      k
+    ] }, k))
+  ] });
+}
+function PushUI({ options }) {
+  const [tasks, setTasks] = useState3([
+    { label: "Loading local schema", status: "pending" },
+    { label: "Validating schema", status: "pending" },
+    { label: "Pushing to platform", status: "pending" }
+  ]);
+  const [result, setResult] = useState3(null);
+  useEffect3(() => {
+    (async () => {
+      setTasks((t) => t.map((task, i) => i === 0 ? { ...task, status: "running" } : task));
+      try {
+        setTasks((t) => [{ ...t[0], status: "done" }, { ...t[1], status: "running" }, t[2]]);
+        const res = await pushLogic(options);
+        setTasks([
+          { label: "Loading local schema", status: "done" },
+          { label: "Validating schema", status: "done" },
+          { label: "Pushing to platform", status: "done" }
+        ]);
+        setResult(res);
+      } catch (err) {
+        setTasks(
+          (t) => t.map((task) => task.status === "running" ? { ...task, status: "error", error: err instanceof Error ? err.message : String(err) } : task)
+        );
+      }
+    })();
+  }, []);
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Banner, { title: "Push Schema" }),
+    /* @__PURE__ */ jsx5(TaskList, { tasks }),
+    result?.diff && /* @__PURE__ */ jsx5(DiffDisplay, { diff: result.diff }),
+    result && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "green", bold: true, children: "Schema pushed successfully!" }) })
+  ] });
+}
+function runPush(options) {
+  if (!isInteractive(options.json)) {
+    pushLogic(options).then(
+      (result) => jsonOutput(result),
+      (err) => jsonOutput({ success: false, error: err.message }, 1)
+    );
+    return;
+  }
+  render3(/* @__PURE__ */ jsx5(PushUI, { options }));
+}
+var init_push = __esm({
+  "src/cli/commands/push.tsx"() {
+    "use strict";
+    init_Banner();
+    init_TaskList();
+    init_api_client();
+    init_credentials();
+    init_output();
+    init_schema_loader();
+    init_schema_validator();
+  }
+});
+
+// src/cli/commands/pull.tsx
+var pull_exports = {};
+__export(pull_exports, {
+  pullLogic: () => pullLogic,
+  runPull: () => runPull
+});
+import { writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+import { render as render4, Box as Box6, Text as Text6 } from "ink";
+import { useEffect as useEffect4, useState as useState4 } from "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+async function pullLogic(options) {
+  const creds = getCredentialsOrExit();
+  const client = new CliApiClient(creds);
+  const environment = options.environment ?? "development";
+  const values = await client.getAllValues(environment);
+  const configDir = findLocalConfigDir();
+  let filePath;
+  if (configDir) {
+    const jsonPath = join4(configDir, `${environment}.json`);
+    writeFileSync3(jsonPath, JSON.stringify(values, null, 2));
+    filePath = jsonPath;
+  }
+  return { success: true, values, environment, filePath };
+}
+function PullUI({ options }) {
+  const [tasks, setTasks] = useState4([
+    { label: `Fetching values for ${options.environment ?? "development"}`, status: "pending" },
+    { label: "Writing to local config", status: "pending" }
+  ]);
+  const [result, setResult] = useState4(null);
+  useEffect4(() => {
+    (async () => {
+      setTasks((t) => t.map((task, i) => i === 0 ? { ...task, status: "running" } : task));
+      try {
+        const res = await pullLogic(options);
+        setTasks([
+          { label: `Fetching values for ${res.environment}`, status: "done" },
+          { label: "Writing to local config", status: res.filePath ? "done" : "pending" }
+        ]);
+        setResult(res);
+      } catch (err) {
+        setTasks(
+          (t) => t.map((task) => task.status === "running" ? { ...task, status: "error", error: err instanceof Error ? err.message : String(err) } : task)
+        );
+      }
+    })();
+  }, []);
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Banner, { title: "Pull Config" }),
+    /* @__PURE__ */ jsx6(TaskList, { tasks }),
+    result && /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs6(Text6, { color: "green", bold: true, children: [
+        "Pulled ",
+        Object.keys(result.values).length,
+        " values for ",
+        result.environment
+      ] }),
+      result.filePath && /* @__PURE__ */ jsxs6(Text6, { color: "gray", children: [
+        "Written to: ",
+        result.filePath
+      ] })
+    ] })
+  ] });
+}
+function runPull(options) {
+  if (!isInteractive(options.json)) {
+    pullLogic(options).then(
+      (result) => jsonOutput(result),
+      (err) => jsonOutput({ success: false, error: err.message }, 1)
+    );
+    return;
+  }
+  render4(/* @__PURE__ */ jsx6(PullUI, { options }));
+}
+var init_pull = __esm({
+  "src/cli/commands/pull.tsx"() {
+    "use strict";
+    init_Banner();
+    init_TaskList();
+    init_api_client();
+    init_credentials();
+    init_output();
+    init_schema_loader();
+  }
+});
+
+// src/cli/commands/set.tsx
+var set_exports = {};
+__export(set_exports, {
+  runSet: () => runSet,
+  setLogic: () => setLogic
+});
+import { render as render5, Box as Box7, Text as Text7 } from "ink";
+import { useEffect as useEffect5, useState as useState5 } from "react";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function parseValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+async function setLogic(key, rawValue, options) {
+  const creds = getCredentialsOrExit();
+  const client = new CliApiClient(creds);
+  const environment = options.environment ?? "development";
+  const tier = options.tier ?? "public";
+  const value = parseValue(rawValue);
+  const env = await client.getEnvironmentByName(environment);
+  if (!env) {
+    throw new Error(`Environment "${environment}" not found. Create it first.`);
+  }
+  const schemas = await client.listSchemas();
+  if (schemas.length > 0) {
+    const schema = options.schemaName ? schemas.find((s) => s.name === options.schemaName) : schemas[0];
+    if (schema?.jsonSchema) {
+      const validation = validateValue(schema.jsonSchema, key, value);
+      if (!validation.valid) {
+        throw new Error(`Validation failed for "${key}": ${validation.errors?.join(", ")}`);
+      }
+    }
+    if (schema) {
+      await client.setValue({
+        schemaId: schema.id,
+        environmentId: env.id,
+        key,
+        value,
+        tier
+      });
+      return { success: true, key, value, tier, environment };
+    }
+  }
+  throw new Error("No schemas found. Push a schema first with `smooai-config push`.");
+}
+function SetUI({ configKey, value, options }) {
+  const [tasks, setTasks] = useState5([
+    { label: "Validating value", status: "pending" },
+    { label: `Setting ${configKey}`, status: "pending" }
+  ]);
+  const [result, setResult] = useState5(null);
+  useEffect5(() => {
+    (async () => {
+      setTasks((t) => t.map((task, i) => i === 0 ? { ...task, status: "running" } : task));
+      try {
+        const res = await setLogic(configKey, value, options);
+        setTasks([
+          { label: "Validating value", status: "done" },
+          { label: `Setting ${configKey}`, status: "done" }
+        ]);
+        setResult(res);
+      } catch (err) {
+        setTasks(
+          (t) => t.map((task) => task.status === "running" ? { ...task, status: "error", error: err instanceof Error ? err.message : String(err) } : task)
+        );
+      }
+    })();
+  }, []);
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Banner, { title: "Set Config Value" }),
+    /* @__PURE__ */ jsx7(TaskList, { tasks }),
+    result && /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Text7, { color: "green", bold: true, children: "Value set successfully!" }),
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        result.key,
+        " = ",
+        JSON.stringify(result.value),
+        " [",
+        result.tier,
+        "] (",
+        result.environment,
+        ")"
+      ] })
+    ] })
+  ] });
+}
+function runSet(key, value, options) {
+  if (!isInteractive(options.json)) {
+    setLogic(key, value, options).then(
+      (result) => jsonOutput(result),
+      (err) => jsonOutput({ success: false, error: err.message }, 1)
+    );
+    return;
+  }
+  render5(/* @__PURE__ */ jsx7(SetUI, { configKey: key, value, options }));
+}
+var init_set = __esm({
+  "src/cli/commands/set.tsx"() {
+    "use strict";
+    init_Banner();
+    init_TaskList();
+    init_api_client();
+    init_credentials();
+    init_output();
+    init_schema_validator();
+  }
+});
+
+// src/cli/commands/get.tsx
+var get_exports = {};
+__export(get_exports, {
+  getLogic: () => getLogic,
+  runGet: () => runGet
+});
+import { render as render6, Box as Box8, Text as Text8 } from "ink";
+import { useEffect as useEffect6, useState as useState6 } from "react";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+async function getLogic(key, options) {
+  const creds = getCredentialsOrExit();
+  const client = new CliApiClient(creds);
+  const environment = options.environment ?? "development";
+  const value = await client.getValue(key, environment);
+  return { success: true, key, value, environment };
+}
+function GetUI({ configKey, options }) {
+  const [tasks, setTasks] = useState6([{ label: `Fetching ${configKey}`, status: "pending" }]);
+  const [result, setResult] = useState6(null);
+  useEffect6(() => {
+    (async () => {
+      setTasks([{ label: `Fetching ${configKey}`, status: "running" }]);
+      try {
+        const res = await getLogic(configKey, options);
+        setTasks([{ label: `Fetching ${configKey}`, status: "done" }]);
+        setResult(res);
+      } catch (err) {
+        setTasks([
+          {
+            label: `Fetching ${configKey}`,
+            status: "error",
+            error: err instanceof Error ? err.message : String(err)
+          }
+        ]);
+      }
+    })();
+  }, []);
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Banner, { title: "Get Config Value" }),
+    /* @__PURE__ */ jsx8(TaskList, { tasks }),
+    result && /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Text8, { bold: true, children: result.key }),
+      /* @__PURE__ */ jsx8(Text8, { children: typeof result.value === "object" ? JSON.stringify(result.value, null, 2) : String(result.value) }),
+      /* @__PURE__ */ jsxs8(Text8, { color: "gray", children: [
+        "Environment: ",
+        result.environment
+      ] })
+    ] })
+  ] });
+}
+function runGet(key, options) {
+  if (!isInteractive(options.json)) {
+    getLogic(key, options).then(
+      (result) => jsonOutput(result),
+      (err) => jsonOutput({ success: false, error: err.message }, 1)
+    );
+    return;
+  }
+  render6(/* @__PURE__ */ jsx8(GetUI, { configKey: key, options }));
+}
+var init_get = __esm({
+  "src/cli/commands/get.tsx"() {
+    "use strict";
+    init_Banner();
+    init_TaskList();
+    init_api_client();
+    init_credentials();
+    init_output();
+  }
+});
+
+// src/cli/commands/list.tsx
+var list_exports = {};
+__export(list_exports, {
+  listLogic: () => listLogic,
+  runList: () => runList
+});
+import { render as render7, Box as Box9, Text as Text9 } from "ink";
+import { useEffect as useEffect7, useState as useState7 } from "react";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+async function listLogic(options) {
+  const creds = getCredentialsOrExit();
+  const client = new CliApiClient(creds);
+  const environment = options.environment ?? "development";
+  const values = await client.getAllValues(environment);
+  return { success: true, environment, values };
+}
+function ListUI({ options }) {
+  const [tasks, setTasks] = useState7([{ label: `Fetching values for ${options.environment ?? "development"}`, status: "pending" }]);
+  const [result, setResult] = useState7(null);
+  useEffect7(() => {
+    (async () => {
+      setTasks([{ label: `Fetching values for ${options.environment ?? "development"}`, status: "running" }]);
+      try {
+        const res = await listLogic(options);
+        setTasks([{ label: `Fetching values for ${res.environment}`, status: "done" }]);
+        setResult(res);
+      } catch (err) {
+        setTasks([
+          {
+            label: `Fetching values for ${options.environment ?? "development"}`,
+            status: "error",
+            error: err instanceof Error ? err.message : String(err)
+          }
+        ]);
+      }
+    })();
+  }, []);
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(Banner, { title: "List Config Values" }),
+    /* @__PURE__ */ jsx9(TaskList, { tasks }),
+    result && /* @__PURE__ */ jsxs9(Box9, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs9(Text9, { bold: true, children: [
+        "Environment: ",
+        result.environment,
+        " (",
+        Object.keys(result.values).length,
+        " values)"
+      ] }),
+      /* @__PURE__ */ jsx9(Box9, { marginTop: 1, flexDirection: "column", children: Object.entries(result.values).map(([key, value]) => /* @__PURE__ */ jsxs9(Box9, { children: [
+        /* @__PURE__ */ jsx9(Text9, { bold: true, color: "cyan", children: key }),
+        /* @__PURE__ */ jsx9(Text9, { children: " = " }),
+        /* @__PURE__ */ jsx9(Text9, { children: typeof value === "object" ? JSON.stringify(value) : String(value) })
+      ] }, key)) }),
+      Object.keys(result.values).length === 0 && /* @__PURE__ */ jsx9(Text9, { color: "gray", children: "No values found for this environment." })
+    ] })
+  ] });
+}
+function runList(options) {
+  if (!isInteractive(options.json)) {
+    listLogic(options).then(
+      (result) => jsonOutput(result),
+      (err) => jsonOutput({ success: false, error: err.message }, 1)
+    );
+    return;
+  }
+  render7(/* @__PURE__ */ jsx9(ListUI, { options }));
+}
+var init_list = __esm({
+  "src/cli/commands/list.tsx"() {
+    "use strict";
+    init_Banner();
+    init_TaskList();
+    init_api_client();
+    init_credentials();
+    init_output();
+  }
+});
+
+// src/cli/commands/diff.tsx
+var diff_exports = {};
+__export(diff_exports, {
+  diffLogic: () => diffLogic,
+  runDiff: () => runDiff
+});
+import { render as render8, Box as Box10, Text as Text10 } from "ink";
+import { useEffect as useEffect8, useState as useState8 } from "react";
+import { Fragment, jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+function computeDiff(local, remote) {
+  const localKeys = new Set(Object.keys(local));
+  const remoteKeys = new Set(Object.keys(remote));
+  const added = [...localKeys].filter((k) => !remoteKeys.has(k));
+  const removed = [...remoteKeys].filter((k) => !localKeys.has(k));
+  const changed = [...localKeys].filter((k) => {
+    if (!remoteKeys.has(k)) return false;
+    return JSON.stringify(local[k]) !== JSON.stringify(remote[k]);
+  });
+  return { added, removed, changed };
+}
+async function diffLogic(options) {
+  const creds = getCredentialsOrExit();
+  const client = new CliApiClient(creds);
+  const loaded = await loadLocalSchema();
+  if (!loaded) {
+    throw new Error("No local schema found. Run `smooai-config init` first.");
+  }
+  const schemas = await client.listSchemas();
+  const schemaName = options.schemaName;
+  const remoteSchema = schemaName ? schemas.find((s) => s.name === schemaName) : schemas[0];
+  if (!remoteSchema) {
+    const added = Object.keys(loaded.jsonSchema);
+    return {
+      success: true,
+      diff: { added, removed: [], changed: [] },
+      hasChanges: added.length > 0
+    };
+  }
+  const diff = computeDiff(loaded.jsonSchema, remoteSchema.jsonSchema);
+  const hasChanges = diff.added.length > 0 || diff.removed.length > 0 || diff.changed.length > 0;
+  return { success: true, diff, hasChanges };
+}
+function DiffUI({ options }) {
+  const [tasks, setTasks] = useState8([
+    { label: "Loading local schema", status: "pending" },
+    { label: "Fetching remote schema", status: "pending" },
+    { label: "Computing diff", status: "pending" }
+  ]);
+  const [result, setResult] = useState8(null);
+  useEffect8(() => {
+    (async () => {
+      setTasks((t) => t.map((task, i) => i === 0 ? { ...task, status: "running" } : task));
+      try {
+        const res = await diffLogic(options);
+        setTasks([
+          { label: "Loading local schema", status: "done" },
+          { label: "Fetching remote schema", status: "done" },
+          { label: "Computing diff", status: "done" }
+        ]);
+        setResult(res);
+      } catch (err) {
+        setTasks(
+          (t) => t.map((task) => task.status === "running" ? { ...task, status: "error", error: err instanceof Error ? err.message : String(err) } : task)
+        );
+      }
+    })();
+  }, []);
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx10(Banner, { title: "Schema Diff" }),
+    /* @__PURE__ */ jsx10(TaskList, { tasks }),
+    result && /* @__PURE__ */ jsx10(Box10, { marginTop: 1, flexDirection: "column", children: !result.hasChanges ? /* @__PURE__ */ jsx10(Text10, { color: "green", bold: true, children: "Schemas are in sync. No changes detected." }) : /* @__PURE__ */ jsxs10(Fragment, { children: [
+      /* @__PURE__ */ jsx10(Text10, { bold: true, children: "Changes:" }),
+      result.diff.added.map((k) => /* @__PURE__ */ jsxs10(Text10, { color: "green", children: [
+        "+ ",
+        k,
+        " (new)"
+      ] }, k)),
+      result.diff.removed.map((k) => /* @__PURE__ */ jsxs10(Text10, { color: "red", children: [
+        "- ",
+        k,
+        " (removed)"
+      ] }, k)),
+      result.diff.changed.map((k) => /* @__PURE__ */ jsxs10(Text10, { color: "yellow", children: [
+        "~ ",
+        k,
+        " (modified)"
+      ] }, k))
+    ] }) })
+  ] });
+}
+function runDiff(options) {
+  if (!isInteractive(options.json)) {
+    diffLogic(options).then(
+      (result) => jsonOutput(result),
+      (err) => jsonOutput({ success: false, error: err.message }, 1)
+    );
+    return;
+  }
+  render8(/* @__PURE__ */ jsx10(DiffUI, { options }));
+}
+var init_diff = __esm({
+  "src/cli/commands/diff.tsx"() {
+    "use strict";
+    init_Banner();
+    init_TaskList();
+    init_api_client();
+    init_credentials();
+    init_output();
+    init_schema_loader();
+  }
+});
+
+// src/cli/index.ts
+import { Command } from "commander";
+var program = new Command();
+program.name("smooai-config").description("Smoo AI Configuration Management CLI").version("1.1.0");
+program.option("--json", "Output in JSON format (auto-enabled when no TTY detected)");
+program.command("init").description("Initialize a project with .smooai-config/ directory").option("--language <lang>", "Project language: typescript, python, go, rust, other", "typescript").action(async (opts) => {
+  const { runInit: runInit2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+  runInit2({ ...opts, json: program.opts().json ?? opts.json });
+});
+program.command("login").description("Store credentials for CLI access").option("--api-key <key>", "API key for authentication").option("--org-id <id>", "Organization ID").option("--base-url <url>", "API base URL", "https://api.smoo.ai").action(async (opts) => {
+  const { runLogin: runLogin2 } = await Promise.resolve().then(() => (init_login(), login_exports));
+  runLogin2({ ...opts, json: program.opts().json ?? opts.json });
+});
+program.command("push").description("Push local config schema to the remote platform").option("--schema-name <name>", "Schema name (default: project directory name)").option("--description <desc>", "Change description for this version").option("--yes", "Skip confirmation prompt").action(async (opts) => {
+  const { runPush: runPush2 } = await Promise.resolve().then(() => (init_push(), push_exports));
+  runPush2({ ...opts, json: program.opts().json ?? opts.json });
+});
+program.command("pull").description("Pull remote config values to local files").option("--environment <env>", "Environment name", "development").action(async (opts) => {
+  const { runPull: runPull2 } = await Promise.resolve().then(() => (init_pull(), pull_exports));
+  runPull2({ ...opts, json: program.opts().json ?? opts.json });
+});
+program.command("set <key> <value>").description("Set a config value on the remote platform").option("--environment <env>", "Environment name", "development").option("--tier <tier>", "Value tier: public, secret, feature_flag", "public").option("--schema-name <name>", "Schema name to use for validation").action(async (key, value, opts) => {
+  const { runSet: runSet2 } = await Promise.resolve().then(() => (init_set(), set_exports));
+  runSet2(key, value, { ...opts, json: program.opts().json ?? opts.json });
+});
+program.command("get <key>").description("Get a config value from the remote platform").option("--environment <env>", "Environment name", "development").action(async (key, opts) => {
+  const { runGet: runGet2 } = await Promise.resolve().then(() => (init_get(), get_exports));
+  runGet2(key, { ...opts, json: program.opts().json ?? opts.json });
+});
+program.command("list").description("List all config values for an environment").option("--environment <env>", "Environment name", "development").action(async (opts) => {
+  const { runList: runList2 } = await Promise.resolve().then(() => (init_list(), list_exports));
+  runList2({ ...opts, json: program.opts().json ?? opts.json });
+});
+program.command("diff").description("Compare local config schema vs remote").option("--schema-name <name>", "Schema name to compare against").action(async (opts) => {
+  const { runDiff: runDiff2 } = await Promise.resolve().then(() => (init_diff(), diff_exports));
+  runDiff2({ ...opts, json: program.opts().json ?? opts.json });
+});
+program.parse();
+//# sourceMappingURL=cli.mjs.map