@oflow-ai/oflow-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const cli_1 = require("./cli");
+const core_1 = require("@oflow-ai/core");
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Read package.json for version
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+// Simple update check (without update-notifier due to type issues)
+try {
+    const updateNotifier = require('update-notifier');
+    const notifier = updateNotifier({ pkg: packageJson });
+    if (notifier.notify) {
+        notifier.notify();
+    }
+}
+catch {
+    // Ignore update check errors
+}
+const program = new commander_1.Command();
+program
+    .name('oflow')
+    .description('AI-powered CLI assistant for terminal')
+    .version(packageJson.version)
+    .option('-m, --model <model>', 'Specify the AI model to use')
+    .option('-d, --directory <dir>', 'Working directory')
+    .option('--yolo', 'Run in yolo mode (auto-approve all operations)')
+    .option('--thinking', 'Show AI thinking/reasoning process')
+    .option('--no-thinking', 'Hide AI thinking/reasoning process')
+    .argument('[prompt]', 'Prompt to send to AI (starts interactive mode if not provided)')
+    .action(async (prompt, options) => {
+    const configManager = (0, core_1.getConfigManager)();
+    // Check authentication
+    if (!configManager.isAuthenticated()) {
+        console.log(chalk_1.default.yellow('Welcome to oflow! Let\'s get you set up.'));
+        console.log('');
+        await runAuthFlow();
+        return;
+    }
+    // Set model if specified
+    if (options.model) {
+        configManager.setDefaultModel(options.model);
+    }
+    // Set thinking mode if specified
+    if (options.thinking === true) {
+        configManager.setShowThinking(true);
+    }
+    else if (options.thinking === false) {
+        configManager.setShowThinking(false);
+    }
+    // Set working directory
+    const workingDir = options.directory || process.cwd();
+    process.chdir(workingDir);
+    if (prompt) {
+        // Single command mode
+        await (0, cli_1.runSingleCommand)(prompt, {
+            model: options.model,
+            yolo: options.yolo
+        });
+    }
+    else {
+        // Interactive mode
+        await (0, cli_1.startInteractiveMode)({
+            model: options.model,
+            yolo: options.yolo
+        });
+    }
+});
+// Auth command
+program
+    .command('auth')
+    .description('Configure authentication')
+    .option('--provider <provider>', 'Provider (openai, deepseek, qwen, etc.)')
+    .action(async (options) => {
+    await runAuthFlow(options.provider);
+});
+// Config command
+program
+    .command('config')
+    .description('View or edit configuration')
+    .option('--list', 'List current configuration')
+    .option('--set <key=value>', 'Set a configuration value')
+    .option('--thinking', 'Toggle thinking process display')
+    .action(async (options) => {
+    const configManager = (0, core_1.getConfigManager)();
+    if (options.list) {
+        console.log(chalk_1.default.bold('Current Configuration:'));
+        console.log(JSON.stringify(configManager.getAll(), null, 2));
+        console.log('');
+        console.log(chalk_1.default.gray(`Config file: ${configManager.getConfigPath()}`));
+    }
+    else if (options.thinking) {
+        const newValue = configManager.toggleShowThinking();
+        console.log(chalk_1.default.green(`✓ Thinking process display: ${newValue ? 'ON' : 'OFF'}`));
+    }
+    else if (options.set) {
+        const [key, value] = options.set.split('=');
+        configManager.set(key, value);
+        console.log(chalk_1.default.green(`Set ${key} = ${value}`));
+    }
+    else {
+        console.log(`Config file: ${configManager.getConfigPath()}`);
+        console.log(`Thinking display: ${configManager.getShowThinking() ? 'ON' : 'OFF'}`);
+    }
+});
+// Models command
+program
+    .command('models')
+    .description('List available AI models')
+    .action(async () => {
+    await listModels();
+});
+async function runAuthFlow(provider) {
+    const inquirer = require('inquirer');
+    const configManager = (0, core_1.getConfigManager)();
+    if (!provider) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'provider',
+                message: 'Select AI provider:',
+                choices: [
+                    { name: '🌐 OpenAI (Official API)', value: 'openai' },
+                    { name: '🔧 Custom (OpenAI-compatible)', value: 'custom' },
+                    { name: '────────── 国内模型 ──────────', value: 'separator', disabled: true },
+                    { name: '🇨🇳 DeepSeek (深度求索) - 推荐推理模型', value: 'deepseek' },
+                    { name: '🇨🇳 Qwen (通义千问)', value: 'qwen' },
+                    { name: '🇨🇳 GLM (智谱)', value: 'zhipu' },
+                    { name: '🇨🇳 Baichuan (百川)', value: 'baichuan' },
+                    { name: '🇨🇳 Yi (零一万物)', value: 'yi' },
+                    { name: '🇨🇳 Moonshot (月之暗面/Kimi)', value: 'moonshot' },
+                    { name: '🇨🇳 SiliconFlow (硅基流动)', value: 'siliconflow' }
+                ]
+            }
+        ]);
+        provider = answers.provider;
+    }
+    // OpenAI
+    if (provider === 'openai') {
+        const answers = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: 'Enter your OpenAI API key:',
+                mask: '*'
+            },
+            {
+                type: 'list',
+                name: 'model',
+                message: 'Select default model:',
+                choices: [
+                    'gpt-4o',
+                    'gpt-4o-mini',
+                    'gpt-4-turbo',
+                    'gpt-3.5-turbo',
+                    'o1-preview',
+                    'o1-mini'
+                ],
+                default: 'gpt-4o'
+            }
+        ]);
+        configManager.setAuth({
+            provider: 'openai',
+            apiKey: answers.apiKey,
+            model: answers.model
+        });
+        configManager.setDefaultModel(answers.model);
+        console.log(chalk_1.default.green('\n✓ Authentication configured successfully!'));
+    }
+    // Custom
+    else if (provider === 'custom') {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'baseUrl',
+                message: 'Enter API base URL:',
+                default: 'https://api.openai.com/v1'
+            },
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: 'Enter your API key:',
+                mask: '*'
+            },
+            {
+                type: 'input',
+                name: 'model',
+                message: 'Enter default model name:',
+                default: 'gpt-4o'
+            }
+        ]);
+        configManager.setAuth({
+            provider: 'custom',
+            apiKey: answers.apiKey,
+            baseUrl: answers.baseUrl,
+            model: answers.model
+        });
+        configManager.setDefaultModel(answers.model);
+        console.log(chalk_1.default.green('\n✓ Authentication configured successfully!'));
+    }
+    // 国内模型
+    else if (core_1.CHINESE_MODELS[provider]) {
+        const modelConfig = core_1.CHINESE_MODELS[provider];
+        console.log(chalk_1.default.cyan(`\n配置 ${modelConfig.name}`));
+        const answers = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: `Enter your ${modelConfig.name} API key:`,
+                mask: '*'
+            },
+            {
+                type: 'list',
+                name: 'model',
+                message: 'Select default model:',
+                choices: modelConfig.models,
+                default: modelConfig.models[0]
+            }
+        ]);
+        configManager.setAuth({
+            provider: provider,
+            apiKey: answers.apiKey,
+            baseUrl: modelConfig.baseUrl,
+            model: answers.model
+        });
+        configManager.setDefaultModel(answers.model);
+        console.log(chalk_1.default.green(`\n✓ ${modelConfig.name} 配置成功!`));
+        // DeepSeek特殊提示
+        if (provider === 'deepseek' && answers.model === 'deepseek-reasoner') {
+            console.log(chalk_1.default.yellow('💡 提示: deepseek-reasoner 支持显示思考过程，使用 --thinking 开启'));
+        }
+    }
+}
+async function listModels() {
+    const configManager = (0, core_1.getConfigManager)();
+    const auth = configManager.getAuth();
+    if (!auth) {
+        console.log(chalk_1.default.red('Not authenticated. Run `oflow auth` first.'));
+        return;
+    }
+    console.log(chalk_1.default.bold('\n═══════════════════════════════════════════════════════════'));
+    console.log(chalk_1.default.bold('                    Available Models                        '));
+    console.log(chalk_1.default.bold('═══════════════════════════════════════════════════════════\n'));
+    // OpenAI Models
+    console.log(chalk_1.default.cyan('🌐 OpenAI Models:'));
+    const openaiModels = [
+        { id: 'gpt-4o', desc: 'Most capable GPT-4 model' },
+        { id: 'gpt-4o-mini', desc: 'Fast and affordable' },
+        { id: 'gpt-4-turbo', desc: 'Previous GPT-4 version' },
+        { id: 'gpt-3.5-turbo', desc: 'Fast and cheap' },
+        { id: 'o1-preview', desc: 'Advanced reasoning' },
+        { id: 'o1-mini', desc: 'Efficient reasoning' }
+    ];
+    openaiModels.forEach(m => {
+        const current = m.id === configManager.getDefaultModel() ? chalk_1.default.green('* ') : '  ';
+        console.log(`${current}${m.id} - ${chalk_1.default.gray(m.desc)}`);
+    });
+    // 国内模型
+    console.log('');
+    console.log(chalk_1.default.cyan('🇨🇳 国内开源模型:\n'));
+    for (const [key, config] of Object.entries(core_1.CHINESE_MODELS)) {
+        console.log(chalk_1.default.bold(`  ${config.name}`));
+        console.log(chalk_1.default.gray(`    API: ${config.baseUrl}`));
+        for (const m of config.models) {
+            const modelId = typeof m === 'string' ? m : m.id;
+            const modelName = typeof m === 'string' ? m : m.name;
+            const modelDesc = typeof m === 'string' ? '' : m.desc;
+            const current = modelId === configManager.getDefaultModel() ? chalk_1.default.green('* ') : '    ';
+            console.log(`${current}${modelId} - ${chalk_1.default.gray(modelName)}${modelDesc ? chalk_1.default.gray(` (${modelDesc})`) : ''}`);
+        }
+        console.log('');
+    }
+    // 显示当前配置
+    console.log(chalk_1.default.bold('───────────────────────────────────────────────────────────'));
+    console.log(`Current model: ${chalk_1.default.green(configManager.getDefaultModel())}`);
+    console.log(`Thinking display: ${configManager.getShowThinking() ? chalk_1.default.green('ON') : chalk_1.default.gray('OFF')}`);
+    console.log('');
+}
+program.parse();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\nimport { Command } from 'commander';\nimport { startInteractiveMode, runSingleCommand } from './cli';\nimport { getConfigManager, CHINESE_MODELS } from '@oflow-ai/core';\nimport chalk from 'chalk';\nimport * as fs from 'fs';\nimport * as path from 'path';\n\n// Read package.json for version\nconst packageJsonPath = path.join(__dirname, '..', 'package.json');\nconst packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));\n\n// Simple update check (without update-notifier due to type issues)\ntry {\n  const updateNotifier = require('update-notifier');\n  const notifier = updateNotifier({ pkg: packageJson });\n  if (notifier.notify) {\n    notifier.notify();\n  }\n} catch {\n  // Ignore update check errors\n}\n\nconst program = new Command();\n\nprogram\n  .name('oflow')\n  .description('AI-powered CLI assistant for terminal')\n  .version(packageJson.version)\n  .option('-m, --model <model>', 'Specify the AI model to use')\n  .option('-d, --directory <dir>', 'Working directory')\n  .option('--yolo', 'Run in yolo mode (auto-approve all operations)')\n  .option('--thinking', 'Show AI thinking/reasoning process')\n  .option('--no-thinking', 'Hide AI thinking/reasoning process')\n  .argument('[prompt]', 'Prompt to send to AI (starts interactive mode if not provided)')\n  .action(async (prompt, options) => {\n    const configManager = getConfigManager();\n    \n    // Check authentication\n    if (!configManager.isAuthenticated()) {\n      console.log(chalk.yellow('Welcome to oflow! Let\\'s get you set up.'));\n      console.log('');\n      await runAuthFlow();\n      return;\n    }\n\n    // Set model if specified\n    if (options.model) {\n      configManager.setDefaultModel(options.model);\n    }\n\n    // Set thinking mode if specified\n    if (options.thinking === true) {\n      configManager.setShowThinking(true);\n    } else if (options.thinking === false) {\n      configManager.setShowThinking(false);\n    }\n\n    // Set working directory\n    const workingDir = options.directory || process.cwd();\n    process.chdir(workingDir);\n\n    if (prompt) {\n      // Single command mode\n      await runSingleCommand(prompt, {\n        model: options.model,\n        yolo: options.yolo\n      });\n    } else {\n      // Interactive mode\n      await startInteractiveMode({\n        model: options.model,\n        yolo: options.yolo\n      });\n    }\n  });\n\n// Auth command\nprogram\n  .command('auth')\n  .description('Configure authentication')\n  .option('--provider <provider>', 'Provider (openai, deepseek, qwen, etc.)')\n  .action(async (options) => {\n    await runAuthFlow(options.provider);\n  });\n\n// Config command\nprogram\n  .command('config')\n  .description('View or edit configuration')\n  .option('--list', 'List current configuration')\n  .option('--set <key=value>', 'Set a configuration value')\n  .option('--thinking', 'Toggle thinking process display')\n  .action(async (options) => {\n    const configManager = getConfigManager();\n    \n    if (options.list) {\n      console.log(chalk.bold('Current Configuration:'));\n      console.log(JSON.stringify(configManager.getAll(), null, 2));\n      console.log('');\n      console.log(chalk.gray(`Config file: ${configManager.getConfigPath()}`));\n    } else if (options.thinking) {\n      const newValue = configManager.toggleShowThinking();\n      console.log(chalk.green(`✓ Thinking process display: ${newValue ? 'ON' : 'OFF'}`));\n    } else if (options.set) {\n      const [key, value] = options.set.split('=');\n      configManager.set(key as any, value);\n      console.log(chalk.green(`Set ${key} = ${value}`));\n    } else {\n      console.log(`Config file: ${configManager.getConfigPath()}`);\n      console.log(`Thinking display: ${configManager.getShowThinking() ? 'ON' : 'OFF'}`);\n    }\n  });\n\n// Models command\nprogram\n  .command('models')\n  .description('List available AI models')\n  .action(async () => {\n    await listModels();\n  });\n\nasync function runAuthFlow(provider?: string): Promise<void> {\n  const inquirer = require('inquirer');\n  const configManager = getConfigManager();\n\n  if (!provider) {\n    const answers = await inquirer.prompt([\n      {\n        type: 'list',\n        name: 'provider',\n        message: 'Select AI provider:',\n        choices: [\n          { name: '🌐 OpenAI (Official API)', value: 'openai' },\n          { name: '🔧 Custom (OpenAI-compatible)', value: 'custom' },\n          { name: '────────── 国内模型 ──────────', value: 'separator', disabled: true },\n          { name: '🇨🇳 DeepSeek (深度求索) - 推荐推理模型', value: 'deepseek' },\n          { name: '🇨🇳 Qwen (通义千问)', value: 'qwen' },\n          { name: '🇨🇳 GLM (智谱)', value: 'zhipu' },\n          { name: '🇨🇳 Baichuan (百川)', value: 'baichuan' },\n          { name: '🇨🇳 Yi (零一万物)', value: 'yi' },\n          { name: '🇨🇳 Moonshot (月之暗面/Kimi)', value: 'moonshot' },\n          { name: '🇨🇳 SiliconFlow (硅基流动)', value: 'siliconflow' }\n        ]\n      }\n    ]);\n    provider = answers.provider;\n  }\n\n  // OpenAI\n  if (provider === 'openai') {\n    const answers = await inquirer.prompt([\n      {\n        type: 'password',\n        name: 'apiKey',\n        message: 'Enter your OpenAI API key:',\n        mask: '*'\n      },\n      {\n        type: 'list',\n        name: 'model',\n        message: 'Select default model:',\n        choices: [\n          'gpt-4o',\n          'gpt-4o-mini',\n          'gpt-4-turbo',\n          'gpt-3.5-turbo',\n          'o1-preview',\n          'o1-mini'\n        ],\n        default: 'gpt-4o'\n      }\n    ]);\n\n    configManager.setAuth({\n      provider: 'openai',\n      apiKey: answers.apiKey,\n      model: answers.model\n    });\n    configManager.setDefaultModel(answers.model);\n\n    console.log(chalk.green('\\n✓ Authentication configured successfully!'));\n  } \n  // Custom\n  else if (provider === 'custom') {\n    const answers = await inquirer.prompt([\n      {\n        type: 'input',\n        name: 'baseUrl',\n        message: 'Enter API base URL:',\n        default: 'https://api.openai.com/v1'\n      },\n      {\n        type: 'password',\n        name: 'apiKey',\n        message: 'Enter your API key:',\n        mask: '*'\n      },\n      {\n        type: 'input',\n        name: 'model',\n        message: 'Enter default model name:',\n        default: 'gpt-4o'\n      }\n    ]);\n\n    configManager.setAuth({\n      provider: 'custom',\n      apiKey: answers.apiKey,\n      baseUrl: answers.baseUrl,\n      model: answers.model\n    });\n    configManager.setDefaultModel(answers.model);\n\n    console.log(chalk.green('\\n✓ Authentication configured successfully!'));\n  }\n  // 国内模型\n  else if (CHINESE_MODELS[provider as keyof typeof CHINESE_MODELS]) {\n    const modelConfig = CHINESE_MODELS[provider as keyof typeof CHINESE_MODELS];\n    \n    console.log(chalk.cyan(`\\n配置 ${modelConfig.name}`));\n    \n    const answers = await inquirer.prompt([\n      {\n        type: 'password',\n        name: 'apiKey',\n        message: `Enter your ${modelConfig.name} API key:`,\n        mask: '*'\n      },\n      {\n        type: 'list',\n        name: 'model',\n        message: 'Select default model:',\n        choices: modelConfig.models,\n        default: modelConfig.models[0]\n      }\n    ]);\n\n    configManager.setAuth({\n      provider: provider as any,\n      apiKey: answers.apiKey,\n      baseUrl: modelConfig.baseUrl,\n      model: answers.model\n    });\n    configManager.setDefaultModel(answers.model);\n\n    console.log(chalk.green(`\\n✓ ${modelConfig.name} 配置成功!`));\n    \n    // DeepSeek特殊提示\n    if (provider === 'deepseek' && answers.model === 'deepseek-reasoner') {\n      console.log(chalk.yellow('💡 提示: deepseek-reasoner 支持显示思考过程，使用 --thinking 开启'));\n    }\n  }\n}\n\nasync function listModels(): Promise<void> {\n  const configManager = getConfigManager();\n  const auth = configManager.getAuth();\n\n  if (!auth) {\n    console.log(chalk.red('Not authenticated. Run `oflow auth` first.'));\n    return;\n  }\n\n  console.log(chalk.bold('\\n═══════════════════════════════════════════════════════════'));\n  console.log(chalk.bold('                    Available Models                        '));\n  console.log(chalk.bold('═══════════════════════════════════════════════════════════\\n'));\n\n  // OpenAI Models\n  console.log(chalk.cyan('🌐 OpenAI Models:'));\n  const openaiModels = [\n    { id: 'gpt-4o', desc: 'Most capable GPT-4 model' },\n    { id: 'gpt-4o-mini', desc: 'Fast and affordable' },\n    { id: 'gpt-4-turbo', desc: 'Previous GPT-4 version' },\n    { id: 'gpt-3.5-turbo', desc: 'Fast and cheap' },\n    { id: 'o1-preview', desc: 'Advanced reasoning' },\n    { id: 'o1-mini', desc: 'Efficient reasoning' }\n  ];\n  openaiModels.forEach(m => {\n    const current = m.id === configManager.getDefaultModel() ? chalk.green('* ') : '  ';\n    console.log(`${current}${m.id} - ${chalk.gray(m.desc)}`);\n  });\n\n  // 国内模型\n  console.log('');\n  console.log(chalk.cyan('🇨🇳 国内开源模型:\\n'));\n\n  for (const [key, config] of Object.entries(CHINESE_MODELS)) {\n    console.log(chalk.bold(`  ${config.name}`));\n    console.log(chalk.gray(`    API: ${config.baseUrl}`));\n    for (const m of config.models) {\n      const modelId = typeof m === 'string' ? m : m.id;\n      const modelName = typeof m === 'string' ? m : m.name;\n      const modelDesc = typeof m === 'string' ? '' : (m as any).desc;\n      const current = modelId === configManager.getDefaultModel() ? chalk.green('* ') : '    ';\n      console.log(`${current}${modelId} - ${chalk.gray(modelName)}${modelDesc ? chalk.gray(` (${modelDesc})`) : ''}`);\n    }\n    console.log('');\n  }\n\n  // 显示当前配置\n  console.log(chalk.bold('───────────────────────────────────────────────────────────'));\n  console.log(`Current model: ${chalk.green(configManager.getDefaultModel())}`);\n  console.log(`Thinking display: ${configManager.getShowThinking() ? chalk.green('ON') : chalk.gray('OFF')}`);\n  console.log('');\n}\n\nprogram.parse();"]}

package/dist/postinstall.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Post-install script for @oflow-ai/oflow-cli
+ * Runs after npm install to display welcome message and instructions
+ */
+declare const chalk: any;
+declare const fs: any;
+declare const path: any;
+declare const nodeVersion: string;
+declare const majorVersion: number;

package/dist/postinstall.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Post-install script for @oflow-ai/oflow-cli
+ * Runs after npm install to display welcome message and instructions
+ */
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+// Check if running in CI or npm install --ignore-scripts
+if (process.env.CI || process.env.npm_config_ignore_scripts) {
+    process.exit(0);
+}
+// Display welcome message
+console.log('');
+console.log(chalk.bold.blue('╔════════════════════════════════════════════════════════════╗'));
+console.log(chalk.bold.blue('║                    Welcome to oFlow CLI                    ║'));
+console.log(chalk.bold.blue('╚════════════════════════════════════════════════════════════╝'));
+console.log('');
+console.log(chalk.green('✓ oFlow CLI installed successfully!'));
+console.log('');
+console.log(chalk.bold('Quick Start:'));
+console.log('');
+console.log(chalk.cyan('  1. Run the CLI:'));
+console.log(chalk.white('     oflow'));
+console.log('');
+console.log(chalk.cyan('  2. Configure authentication:'));
+console.log(chalk.white('     oflow auth'));
+console.log('');
+console.log(chalk.cyan('  3. Available AI Providers:'));
+console.log(chalk.gray('     • OpenAI (GPT-4o, GPT-4-turbo, etc.)'));
+console.log(chalk.gray('     • DeepSeek (深度求索) - Recommended'));
+console.log(chalk.gray('     • Qwen (通义千问)'));
+console.log(chalk.gray('     • GLM (智谱)'));
+console.log(chalk.gray('     • Baichuan (百川)'));
+console.log(chalk.gray('     • Yi (零一万物)'));
+console.log(chalk.gray('     • Moonshot (月之暗面/Kimi)'));
+console.log(chalk.gray('     • SiliconFlow (硅基流动)'));
+console.log('');
+console.log(chalk.bold('Options:'));
+console.log(chalk.gray('  oflow --help          Show help'));
+console.log(chalk.gray('  oflow --thinking      Show AI reasoning process'));
+console.log(chalk.gray('  oflow models          List available models'));
+console.log(chalk.gray('  oflow config          View configuration'));
+console.log('');
+console.log(chalk.bold('Documentation:'));
+console.log(chalk.blue('  https://github.com/oflow-ai/oflow-cli'));
+console.log('');
+// Check Node.js version
+const nodeVersion = process.version;
+const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+if (majorVersion < 18) {
+    console.log(chalk.yellow('⚠ Warning: Node.js 18 or higher is recommended.'));
+    console.log(chalk.yellow(`  Current version: ${nodeVersion}`));
+    console.log('');
+}
+process.exit(0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9zdGluc3RhbGwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvcG9zdGluc3RhbGwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQTs7O0dBR0c7QUFFSCxNQUFNLEtBQUssR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUM7QUFDL0IsTUFBTSxFQUFFLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ3pCLE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUU3Qix5REFBeUQ7QUFDekQsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLHlCQUF5QixFQUFFLENBQUM7SUFDNUQsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUNsQixDQUFDO0FBRUQsMEJBQTBCO0FBQzFCLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDaEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxnRUFBZ0UsQ0FBQyxDQUFDLENBQUM7QUFDL0YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxnRUFBZ0UsQ0FBQyxDQUFDLENBQUM7QUFDL0YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxnRUFBZ0UsQ0FBQyxDQUFDLENBQUM7QUFDL0YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQztBQUNoQixPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMscUNBQXFDLENBQUMsQ0FBQyxDQUFDO0FBQ2hFLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDaEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUM7QUFDeEMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQztBQUNoQixPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDO0FBQzdDLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDO0FBQ3ZDLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDaEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLGdDQUFnQyxDQUFDLENBQUMsQ0FBQztBQUMxRCxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxDQUFDO0FBQzVDLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDaEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLDhCQUE4QixDQUFDLENBQUMsQ0FBQztBQUN4RCxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsMkNBQTJDLENBQUMsQ0FBQyxDQUFDO0FBQ3JFLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxzQ0FBc0MsQ0FBQyxDQUFDLENBQUM7QUFDaEUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLG9CQUFvQixDQUFDLENBQUMsQ0FBQztBQUM5QyxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxDQUFDO0FBQzNDLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDLENBQUM7QUFDaEQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUMsQ0FBQztBQUM1QyxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsNkJBQTZCLENBQUMsQ0FBQyxDQUFDO0FBQ3ZELE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQywyQkFBMkIsQ0FBQyxDQUFDLENBQUM7QUFDckQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQztBQUNoQixPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQztBQUNwQyxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsbUNBQW1DLENBQUMsQ0FBQyxDQUFDO0FBQzdELE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxtREFBbUQsQ0FBQyxDQUFDLENBQUM7QUFDN0UsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLCtDQUErQyxDQUFDLENBQUMsQ0FBQztBQUN6RSxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsNENBQTRDLENBQUMsQ0FBQyxDQUFDO0FBQ3RFLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDaEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLENBQUMsQ0FBQztBQUMxQyxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMseUNBQXlDLENBQUMsQ0FBQyxDQUFDO0FBQ25FLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7QUFFaEIsd0JBQXdCO0FBQ3hCLE1BQU0sV0FBVyxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUM7QUFDcEMsTUFBTSxZQUFZLEdBQUcsUUFBUSxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0FBRXRFLElBQUksWUFBWSxHQUFHLEVBQUUsRUFBRSxDQUFDO0lBQ3RCLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxpREFBaUQsQ0FBQyxDQUFDLENBQUM7SUFDN0UsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLHNCQUFzQixXQUFXLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDL0QsT0FBTyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQztBQUNsQixDQUFDO0FBRUQsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIiMhL3Vzci9iaW4vZW52IG5vZGVcblxuLyoqXG4gKiBQb3N0LWluc3RhbGwgc2NyaXB0IGZvciBAb2Zsb3ctYWkvb2Zsb3ctY2xpXG4gKiBSdW5zIGFmdGVyIG5wbSBpbnN0YWxsIHRvIGRpc3BsYXkgd2VsY29tZSBtZXNzYWdlIGFuZCBpbnN0cnVjdGlvbnNcbiAqL1xuXG5jb25zdCBjaGFsayA9IHJlcXVpcmUoJ2NoYWxrJyk7XG5jb25zdCBmcyA9IHJlcXVpcmUoJ2ZzJyk7XG5jb25zdCBwYXRoID0gcmVxdWlyZSgncGF0aCcpO1xuXG4vLyBDaGVjayBpZiBydW5uaW5nIGluIENJIG9yIG5wbSBpbnN0YWxsIC0taWdub3JlLXNjcmlwdHNcbmlmIChwcm9jZXNzLmVudi5DSSB8fCBwcm9jZXNzLmVudi5ucG1fY29uZmlnX2lnbm9yZV9zY3JpcHRzKSB7XG4gIHByb2Nlc3MuZXhpdCgwKTtcbn1cblxuLy8gRGlzcGxheSB3ZWxjb21lIG1lc3NhZ2VcbmNvbnNvbGUubG9nKCcnKTtcbmNvbnNvbGUubG9nKGNoYWxrLmJvbGQuYmx1ZSgn4pWU4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWXJykpO1xuY29uc29sZS5sb2coY2hhbGsuYm9sZC5ibHVlKCfilZEgICAgICAgICAgICAgICAgICAgIFdlbGNvbWUgdG8gb0Zsb3cgQ0xJICAgICAgICAgICAgICAgICAgICDilZEnKSk7XG5jb25zb2xlLmxvZyhjaGFsay5ib2xkLmJsdWUoJ+KVmuKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVnScpKTtcbmNvbnNvbGUubG9nKCcnKTtcbmNvbnNvbGUubG9nKGNoYWxrLmdyZWVuKCfinJMgb0Zsb3cgQ0xJIGluc3RhbGxlZCBzdWNjZXNzZnVsbHkhJykpO1xuY29uc29sZS5sb2coJycpO1xuY29uc29sZS5sb2coY2hhbGsuYm9sZCgnUXVpY2sgU3RhcnQ6JykpO1xuY29uc29sZS5sb2coJycpO1xuY29uc29sZS5sb2coY2hhbGsuY3lhbignICAxLiBSdW4gdGhlIENMSTonKSk7XG5jb25zb2xlLmxvZyhjaGFsay53aGl0ZSgnICAgICBvZmxvdycpKTtcbmNvbnNvbGUubG9nKCcnKTtcbmNvbnNvbGUubG9nKGNoYWxrLmN5YW4oJyAgMi4gQ29uZmlndXJlIGF1dGhlbnRpY2F0aW9uOicpKTtcbmNvbnNvbGUubG9nKGNoYWxrLndoaXRlKCcgICAgIG9mbG93IGF1dGgnKSk7XG5jb25zb2xlLmxvZygnJyk7XG5jb25zb2xlLmxvZyhjaGFsay5jeWFuKCcgIDMuIEF2YWlsYWJsZSBBSSBQcm92aWRlcnM6JykpO1xuY29uc29sZS5sb2coY2hhbGsuZ3JheSgnICAgICDigKIgT3BlbkFJIChHUFQtNG8sIEdQVC00LXR1cmJvLCBldGMuKScpKTtcbmNvbnNvbGUubG9nKGNoYWxrLmdyYXkoJyAgICAg4oCiIERlZXBTZWVrICjmt7HluqbmsYLntKIpIC0gUmVjb21tZW5kZWQnKSk7XG5jb25zb2xlLmxvZyhjaGFsay5ncmF5KCcgICAgIOKAoiBRd2VuICjpgJrkuYnljYPpl64pJykpO1xuY29uc29sZS5sb2coY2hhbGsuZ3JheSgnICAgICDigKIgR0xNICjmmbrosLEpJykpO1xuY29uc29sZS5sb2coY2hhbGsuZ3JheSgnICAgICDigKIgQmFpY2h1YW4gKOeZvuW3nSknKSk7XG5jb25zb2xlLmxvZyhjaGFsay5ncmF5KCcgICAgIOKAoiBZaSAo6Zu25LiA5LiH54mpKScpKTtcbmNvbnNvbGUubG9nKGNoYWxrLmdyYXkoJyAgICAg4oCiIE1vb25zaG90ICjmnIjkuYvmmpfpnaIvS2ltaSknKSk7XG5jb25zb2xlLmxvZyhjaGFsay5ncmF5KCcgICAgIOKAoiBTaWxpY29uRmxvdyAo56GF5Z+65rWB5YqoKScpKTtcbmNvbnNvbGUubG9nKCcnKTtcbmNvbnNvbGUubG9nKGNoYWxrLmJvbGQoJ09wdGlvbnM6JykpO1xuY29uc29sZS5sb2coY2hhbGsuZ3JheSgnICBvZmxvdyAtLWhlbHAgICAgICAgICAgU2hvdyBoZWxwJykpO1xuY29uc29sZS5sb2coY2hhbGsuZ3JheSgnICBvZmxvdyAtLXRoaW5raW5nICAgICAgU2hvdyBBSSByZWFzb25pbmcgcHJvY2VzcycpKTtcbmNvbnNvbGUubG9nKGNoYWxrLmdyYXkoJyAgb2Zsb3cgbW9kZWxzICAgICAgICAgIExpc3QgYXZhaWxhYmxlIG1vZGVscycpKTtcbmNvbnNvbGUubG9nKGNoYWxrLmdyYXkoJyAgb2Zsb3cgY29uZmlnICAgICAgICAgIFZpZXcgY29uZmlndXJhdGlvbicpKTtcbmNvbnNvbGUubG9nKCcnKTtcbmNvbnNvbGUubG9nKGNoYWxrLmJvbGQoJ0RvY3VtZW50YXRpb246JykpO1xuY29uc29sZS5sb2coY2hhbGsuYmx1ZSgnICBodHRwczovL2dpdGh1Yi5jb20vb2Zsb3ctYWkvb2Zsb3ctY2xpJykpO1xuY29uc29sZS5sb2coJycpO1xuXG4vLyBDaGVjayBOb2RlLmpzIHZlcnNpb25cbmNvbnN0IG5vZGVWZXJzaW9uID0gcHJvY2Vzcy52ZXJzaW9uO1xuY29uc3QgbWFqb3JWZXJzaW9uID0gcGFyc2VJbnQobm9kZVZlcnNpb24uc2xpY2UoMSkuc3BsaXQoJy4nKVswXSwgMTApO1xuXG5pZiAobWFqb3JWZXJzaW9uIDwgMTgpIHtcbiAgY29uc29sZS5sb2coY2hhbGsueWVsbG93KCfimqAgV2FybmluZzogTm9kZS5qcyAxOCBvciBoaWdoZXIgaXMgcmVjb21tZW5kZWQuJykpO1xuICBjb25zb2xlLmxvZyhjaGFsay55ZWxsb3coYCAgQ3VycmVudCB2ZXJzaW9uOiAke25vZGVWZXJzaW9ufWApKTtcbiAgY29uc29sZS5sb2coJycpO1xufVxuXG5wcm9jZXNzLmV4aXQoMCk7XG4iXX0=

package/dist/utils/markdown.d.ts

@@ -0,0 +1,10 @@
+export declare function renderMarkdown(content: string): string;
+export declare function formatCodeBlock(code: string, language?: string): string;
+export declare function formatInlineCode(code: string): string;
+export declare function formatLink(text: string, url: string): string;
+export declare function formatBullet(text: string, level?: number): string;
+export declare function formatNumberedList(items: string[]): string;
+export declare function formatError(message: string): string;
+export declare function formatSuccess(message: string): string;
+export declare function formatWarning(message: string): string;
+export declare function formatInfo(message: string): string;

package/dist/utils/markdown.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMarkdown = renderMarkdown;
+exports.formatCodeBlock = formatCodeBlock;
+exports.formatInlineCode = formatInlineCode;
+exports.formatLink = formatLink;
+exports.formatBullet = formatBullet;
+exports.formatNumberedList = formatNumberedList;
+exports.formatError = formatError;
+exports.formatSuccess = formatSuccess;
+exports.formatWarning = formatWarning;
+exports.formatInfo = formatInfo;
+const chalk_1 = __importDefault(require("chalk"));
+function renderMarkdown(content) {
+    // Simple markdown rendering
+    let result = content;
+    // Bold
+    result = result.replace(/\*\*(.*?)\*\*/g, (_, text) => chalk_1.default.bold(text));
+    // Italic
+    result = result.replace(/\*(.*?)\*/g, (_, text) => chalk_1.default.italic(text));
+    // Code blocks
+    result = result.replace(/```(\w*)\n([\s\S]*?)```/g, (_, lang, code) => {
+        return chalk_1.default.cyan(code);
+    });
+    // Inline code
+    result = result.replace(/`([^`]+)`/g, (_, code) => chalk_1.default.cyan(code));
+    // Headers
+    result = result.replace(/^### (.+)$/gm, (_, text) => chalk_1.default.bold.green(text));
+    result = result.replace(/^## (.+)$/gm, (_, text) => chalk_1.default.bold.green(text));
+    result = result.replace(/^# (.+)$/gm, (_, text) => chalk_1.default.bold.green(text));
+    // Links
+    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, text, url) => `${chalk_1.default.blue.underline(text)} ${chalk_1.default.gray(`(${url})`)}`);
+    return result;
+}
+function formatCodeBlock(code, language) {
+    const header = language ? chalk_1.default.gray(`\`\`\`${language}\n`) : chalk_1.default.gray('```\n');
+    const footer = chalk_1.default.gray('\n```');
+    return header + chalk_1.default.cyan(code) + footer;
+}
+function formatInlineCode(code) {
+    return chalk_1.default.cyan(`\`${code}\``);
+}
+function formatLink(text, url) {
+    return `${chalk_1.default.blue.underline(text)} ${chalk_1.default.gray(`(${url})`)}`;
+}
+function formatBullet(text, level = 0) {
+    const indent = '  '.repeat(level);
+    const bullet = level === 0 ? '•' : '◦';
+    return `${indent}${chalk_1.default.cyan(bullet)} ${text}`;
+}
+function formatNumberedList(items) {
+    return items.map((item, index) => `${chalk_1.default.cyan(`${index + 1}.`)} ${item}`).join('\n');
+}
+function formatError(message) {
+    return chalk_1.default.red(`✗ Error: ${message}`);
+}
+function formatSuccess(message) {
+    return chalk_1.default.green(`✓ ${message}`);
+}
+function formatWarning(message) {
+    return chalk_1.default.yellow(`⚠ ${message}`);
+}
+function formatInfo(message) {
+    return chalk_1.default.blue(`ℹ ${message}`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@oflow-ai/oflow-cli",
+  "version": "0.1.0",
+  "description": "oFlow CLI - AI-powered terminal assistant for developers",
+  "keywords": [
+    "ai",
+    "cli",
+    "assistant",
+    "terminal",
+    "code-assistant",
+    "gpt",
+    "openai",
+    "deepseek",
+    "qwen",
+    "developer-tools"
+  ],
+  "homepage": "https://github.com/oflow-ai/oflow-cli#readme",
+  "bugs": {
+    "url": "https://github.com/oflow-ai/oflow-cli/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oflow-ai/oflow-cli.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "oflow": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "tsc -b --watch",
+    "test": "echo \"No tests yet\"",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "dependencies": {
+    "@oflow-ai/core": "^0.1.0",
+    "commander": "^11.1.0",
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "inquirer": "^8.2.6",
+    "conf": "^10.2.0",
+    "marked": "^11.1.0",
+    "marked-terminal": "^6.0.0",
+    "update-notifier": "^6.0.2",
+    "open": "^8.4.2"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^8.2.10",
+    "@types/node": "^20.10.0",
+    "@types/update-notifier": "^6.0.5",
+    "typescript": "^5.3.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "author": "oFlow Team",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}