@jixo/cli 0.3.0 → 0.5.0

package/src/commands/doctor/doctor.ts

@@ -1,151 +0,0 @@
-// doctor.ts
-import {blue, cyan, green, red, spinner, yellow} from "@gaubee/nodekit";
-import {execSync} from "child_process";
-import semver from "semver";
-
-import {iter_map_not_null} from "@gaubee/util";
-import type {DoctorConfig} from "./types.js"; // Assuming types.ts
-
-const CHECK_MARK = green("✔");
-const CROSS_MARK = red("✖");
-const WARN_MARK = yellow("⚠");
-
-export interface ToolCheckResult {
-  id: string;
-  displayName: string;
-  exists: boolean;
-  version?: string; // Actual version found
-  requiredVersion?: string; // From config
-  meetsVersionRequirement: boolean; // True if version >= minVersion or if minVersion not set & exists
-  isOptional: boolean;
-  message: string;
-  installationHint?: string;
-}
-
-export interface DoctorReport {
-  overallSuccess: boolean;
-  results: ToolCheckResult[];
-}
-
-async function executeCommand(command: string): Promise<{stdout: string; stderr: string; error?: Error}> {
-  return new Promise((resolve) => {
-    try {
-      const stdout = execSync(command, {encoding: "utf8", stdio: "pipe"});
-      resolve({stdout, stderr: ""});
-    } catch (e: any) {
-      resolve({stdout: "", stderr: e.stderr || "", error: e});
-    }
-  });
-}
-
-export async function runDoctor(config: DoctorConfig, enableLog: boolean = true): Promise<DoctorReport> {
-  const LOG_TITLE = "Running Environment Doctor 🏥\n\n";
-  const logger = spinner(LOG_TITLE);
-  if (enableLog) {
-    logger.start();
-  }
-
-  const results: ToolCheckResult[] = [];
-  let overallSuccess = true;
-  let overallWarn = false;
-
-  const tool_logs: string[] = [];
-
-  for (const [index, tool] of config.entries()) {
-    const TOOL_LOG_TITLE = `${blue(`[${tool.id}]`)} ${cyan(tool.displayName)}`;
-    const SUCCESS_MARK = () => CHECK_MARK;
-    const FAIL_MARK = () => {
-      overallWarn = true;
-      return tool.optional ? WARN_MARK : CROSS_MARK;
-    };
-    const setToolLog = (update: (cur: string) => string | (string | undefined | null)[]) => {
-      const log = update(tool_logs[index] ?? "");
-      tool_logs[index] = (Array.isArray(log) ? iter_map_not_null(log, (v) => (v ? v : null)) : [log]).map((line) => "   " + line).join("\n");
-      logger.text = LOG_TITLE + tool_logs.join("\n");
-    };
-    setToolLog(() => `Checking ${TOOL_LOG_TITLE}... `);
-    let tool_log: (string | undefined | null)[] = [];
-
-    const result: ToolCheckResult = {
-      id: tool.id,
-      displayName: tool.displayName,
-      exists: false,
-      meetsVersionRequirement: false, // Assume failure until proven otherwise
-      isOptional: !!tool.optional,
-      message: "",
-      requiredVersion: tool.minVersion,
-      installationHint: tool.installationHint,
-    };
-
-    const execResult = await executeCommand(tool.versionCommand);
-
-    if (execResult.error || execResult.stderr.includes("command not found") || execResult.stderr.includes("not recognized")) {
-      result.exists = false;
-      result.message = `'${tool.id}' command not found or failed to execute.`;
-      tool_log = [
-        //
-        `${FAIL_MARK()} ${TOOL_LOG_TITLE}`,
-        `  ${red(result.message)}`,
-        tool.installationHint && `  ${yellow("Hint:")} ${tool.installationHint}`,
-      ];
-    } else {
-      result.exists = true;
-      const output = execResult.stdout.trim();
-      const match = output.match(tool.versionParseRegex);
-
-      if (match && match[1]) {
-        result.version = semver.clean(match[1]) || undefined; // Clean the version string
-        if (result.version) {
-          if (tool.minVersion) {
-            if (semver.gte(result.version, tool.minVersion)) {
-              result.meetsVersionRequirement = true;
-              result.message = `Version ${result.version} satisfies >=${tool.minVersion}.`;
-              tool_log.push(`${SUCCESS_MARK()} ${TOOL_LOG_TITLE} (v${result.version})`);
-            } else {
-              result.meetsVersionRequirement = false;
-              result.message = `Version ${result.version} is older than required >=${tool.minVersion}.`;
-              tool_log.push(`${FAIL_MARK()} ${TOOL_LOG_TITLE} (v${result.version} - required: >=${tool.minVersion})`);
-              tool_log.push(`  ${red(result.message)}`);
-              if (tool.installationHint) {
-                tool_log.push(`  ${yellow("Hint:")} ${tool.installationHint}`);
-              }
-            }
-          } else {
-            // No minimum version specified, just existence is enough
-            result.meetsVersionRequirement = true;
-            result.message = `Found version ${result.version}. No minimum version specified.`;
-            tool_log.push(`${SUCCESS_MARK()} ${TOOL_LOG_TITLE} (v${result.version} - existence check only)`);
-          }
-        } else {
-          // Regex matched but couldn't clean version (should be rare with semver.clean)
-          result.meetsVersionRequirement = false;
-          result.message = `Could not parse a valid version string from output: "${output}". Regex: ${tool.versionParseRegex}`;
-          tool_log.push(`${FAIL_MARK()} ${TOOL_LOG_TITLE}`);
-          tool_log.push(`  ${red(result.message)}`);
-        }
-      } else {
-        result.meetsVersionRequirement = false;
-        result.message = `Could not parse version from output: "${output}". Regex: ${tool.versionParseRegex}`;
-        tool_log.push(`${FAIL_MARK}`);
-        tool_log.push(`  ${red(result.message)}`);
-      }
-    }
-
-    setToolLog(() => tool_log);
-
-    results.push(result);
-    if (!result.meetsVersionRequirement && !result.isOptional) {
-      overallSuccess = false;
-    }
-  }
-
-  const LOG_SUMMERY = `${overallSuccess ? (overallWarn ? "⚠️ " : "✅") : "💊"} JIXO Environment Doctor 🏥\n\n`;
-  logger.stopAndPersist({
-    text: LOG_SUMMERY + tool_logs.join("\n") + "\n",
-  });
-
-  return {
-    overallSuccess,
-    results,
-  };
-}

package/src/commands/doctor/index.ts

@@ -1,21 +0,0 @@
-// import {bgGreen, bgRed, black, white} from "@gaubee/nodekit"; // For the final message
-import {func_remember} from "@gaubee/util";
-import {myDoctorConfig} from "./config.js";
-import {runDoctor} from "./doctor.js";
-
-export const doctor = func_remember(async (enableLog: boolean = true) => {
-  const report = await runDoctor(myDoctorConfig, enableLog);
-
-  //   if (log) {
-  //     console.log("\n\n--- Structured Report (for programmatic use) ---");
-  //     console.log(JSON.stringify(report, null, 2));
-
-  //     if (!report.overallSuccess) {
-  //       console.error(bgRed(white("\nCritical environment checks failed. Please fix the issues above before proceeding.")));
-  //       // process.exit(1); // Optionally exit if critical checks fail in a real CLI
-  //     } else {
-  //       console.log(bgGreen(black("\nAll critical checks passed successfully!")));
-  //     }
-  //   }
-  return report;
-});

package/src/commands/doctor/types.ts

@@ -1,39 +0,0 @@
-
-// types.ts (or directly in your doctor.ts)
-
-export interface ToolCheckConfig {
-  /** A unique identifier for this check (e.g., 'pnpm', 'uvx-cli') */
-  id: string;
-
-  /** User-friendly name for display purposes (e.g., "PNPM Package Manager") */
-  displayName: string;
-
-  /** The command to execute to get the version (e.g., "pnpm --version") */
-  versionCommand: string;
-
-  /**
-   * A regular expression to parse the version string from the command's output.
-   * It MUST have at least one capturing group, which should capture the version string.
-   * Example: For "pnpm 10.11.0", regex could be /pnpm\s+([\d.]+)/ or simply /([\d.]+)/
-   */
-  versionParseRegex: RegExp;
-
-  /**
-   * The minimum required version (Semantic Versioning string).
-   * If undefined, only existence is checked.
-   */
-  minVersion?: string;
-
-  /**
-   * Optional: A hint or URL for installation if the tool is missing or version is too low.
-   */
-  installationHint?: string;
-
-  /**
-   * Optional: If true, a failure for this tool won't cause the overall doctor check to fail.
-   * It will still be reported. Defaults to false.
-   */
-  optional?: boolean;
-}
-
-export type DoctorConfig = ToolCheckConfig[];

package/src/commands/init.ts

@@ -1,64 +0,0 @@
-import {writeJson, writeMarkdown, writeText} from "@gaubee/nodekit";
-import {str_trim_indent} from "@gaubee/util";
-import fs from "node:fs";
-import path from "node:path";
-import type {JixoConfig} from "../config.js";
-import {safeEnv} from "../env.js";
-export const init = (dir: string) => {
-  const jixoDirname = path.join(dir, ".jixo");
-  /// 创建 .jixo 目录
-  fs.mkdirSync(jixoDirname, {recursive: true});
-  {
-    /// .jixo/readme.task.md
-    const readmeTaskFilepath = path.join(jixoDirname, "readme.task.md");
-    if (!fs.existsSync(readmeTaskFilepath)) {
-      writeMarkdown(
-        readmeTaskFilepath,
-        str_trim_indent(`
-        <!-- 您可以自定义 readme.md 文件的格式 -->
-        请JIXO帮我生成或者追加 README 文件
-        `),
-        {
-          agents: ["readme-writer"],
-        },
-      );
-    }
-  }
-  /// 配置文件
-  {
-    const jixoConfigFilepath = path.join(jixoDirname, "jixo.config.json");
-    if (!fs.existsSync(jixoConfigFilepath)) {
-      writeJson(jixoConfigFilepath, {
-        tasks: {type: "dir", dirname: ".jixo"},
-      } satisfies JixoConfig);
-    }
-  }
-  /// .jixo.env
-  {
-    const jixoEnvFilepath = path.join(dir, ".jixo.env");
-    if (!fs.existsSync(jixoEnvFilepath)) {
-      writeText(
-        jixoEnvFilepath,
-        Object.keys(safeEnv)
-          .filter((key) => key.startsWith("JIXO_"))
-          .map((key) => `${key}=""`)
-          .join("\n"),
-      );
-    }
-  }
-  /// .gitignore
-  {
-    const gitignoreFilepath = path.join(dir, ".gitignore");
-    const gitignoreLines = (fs.existsSync(gitignoreFilepath) ? fs.readFileSync(gitignoreFilepath, "utf-8") : "").split(/\n+/);
-    let changed = false;
-    for (const line of ["*.memory.json", "memory.json", ".jixo.env"]) {
-      if (!gitignoreLines.includes(line)) {
-        gitignoreLines.unshift(line);
-        changed = true;
-      }
-    }
-    if (changed) {
-      fs.writeFileSync(gitignoreFilepath, gitignoreLines.join("\n"));
-    }
-  }
-};

package/src/commands/prompts/list.ts

@@ -1,14 +0,0 @@
-import {cyan, gray} from "@gaubee/nodekit";
-import {obj_props} from "@gaubee/util";
-import {getPromptConfigs} from "../../helper/prompts-loader.js";
-
-export const listPrompts = async () => {
-  const configs = await getPromptConfigs();
-  for (const key of obj_props(configs)) {
-    const config = configs[key];
-    console.log(`- ${cyan(key)}: ${gray(config.content.split("\n")[0])}...`);
-    if (config.data.parent.length) {
-      console.log(`  parent: ${config.data.parent.map(cyan).join(", ")}`);
-    }
-  }
-};

package/src/commands/prompts/upgrade.ts

@@ -1,16 +0,0 @@
-import {spinner, writeJson} from "@gaubee/nodekit";
-
-export const upgradePrompts = async (dir: string, options: {mirrorUrl?: string}) => {
-  // TODO 下载最新的提示词集合
-  const mirrorUrl = options.mirrorUrl || "https://jixo.ai/jixo-prompts.json";
-  const loading = spinner("Upgrading prompts");
-  loading.start("Downloading...");
-  //   await delay(1000);
-  try {
-    const prompts = await fetch(mirrorUrl).then((res) => res.json());
-    loading.stopAndPersist({symbol: "✅", text: "Download completed"});
-    writeJson(import.meta.resolve("jixo-prompts.json"), prompts);
-  } catch (e) {
-    loading.stopAndPersist({symbol: "❌", text: "Download failed"});
-  }
-};

package/src/commands/tasks/ai-tools.ts

@@ -1,65 +0,0 @@
-import {func_lazy, func_remember, map_get_or_put_async} from "@gaubee/util";
-import {experimental_createMCPClient as createMCPClient, type ToolSet} from "ai";
-import {Experimental_StdioMCPTransport} from "ai/mcp-stdio";
-
-export const tools = {
-  fileSystem: func_lazy(() => {
-    const map = new Map<string, ToolSet>();
-    return (cwd: string) => {
-      return map_get_or_put_async(map, cwd, async () => {
-        const mcpClient = await createMCPClient({
-          transport: new Experimental_StdioMCPTransport({
-            command: "pnpx",
-            args: ["@modelcontextprotocol/server-filesystem", cwd],
-          }),
-        });
-        const tools = await mcpClient.tools();
-        return tools;
-      });
-    };
-  }),
-  memory: func_lazy(() => {
-    const map = new Map<string, ToolSet>();
-    return (memory_filepath: string) => {
-      return map_get_or_put_async(map, memory_filepath, async () => {
-        const mcpClient = await createMCPClient({
-          transport: new Experimental_StdioMCPTransport({
-            command: "pnpx",
-            args: ["@modelcontextprotocol/server-memory"],
-            env: {
-              MEMORY_FILE_PATH: memory_filepath,
-            },
-          }),
-        });
-        const tools = await mcpClient.tools();
-        return tools;
-      });
-    };
-  }),
-  fetch: func_remember(async () => {
-    const mcpClient = await createMCPClient({
-      transport: new Experimental_StdioMCPTransport({
-        command: "uvx",
-        args: ["mcp-server-fetch"],
-      }),
-    });
-    const tools = await mcpClient.tools();
-    return tools;
-  }),
-  git: func_lazy(() => {
-    const map = new Map<string, ToolSet>();
-
-    return (repo: string) => {
-      return map_get_or_put_async(map, repo, async () => {
-        const mcpClient = await createMCPClient({
-          transport: new Experimental_StdioMCPTransport({
-            command: "uvx",
-            args: ["mcp-server-git", "--repository", repo],
-          }),
-        });
-        const tools = await mcpClient.tools();
-        return tools;
-      });
-    };
-  }),
-};

package/src/commands/tasks/model-providers.ts

@@ -1,54 +0,0 @@
-import {createAnthropic} from "@ai-sdk/anthropic";
-import {createDeepInfra} from "@ai-sdk/deepinfra";
-import {createDeepSeek} from "@ai-sdk/deepseek";
-import {createGoogleGenerativeAI} from "@ai-sdk/google";
-import {createOpenAI} from "@ai-sdk/openai";
-import {createXai} from "@ai-sdk/xai";
-import {obj_lazify} from "@gaubee/util";
-import {safeEnv} from "../../env.js";
-
-// const wrapper = (provider:)
-export const providers = obj_lazify({
-  get deepseek() {
-    return createDeepSeek({
-      baseURL: safeEnv.JIXO_DEEPSEEK_BASE_URL || undefined,
-      apiKey: safeEnv.JIXO_DEEPSEEK_API_KEY,
-    });
-  },
-  get anthropic() {
-    // const bashTool = anthropic.tools.bash_20250124({
-    //   execute: async ({command, restart}) => execSync(command).toString(),
-    // });
-
-    const provider = createAnthropic({
-      baseURL: safeEnv.JIXO_ANTHROPIC_BASE_URL || undefined,
-      apiKey: safeEnv.JIXO_ANTHROPIC_API_KEY,
-    });
-    return provider;
-  },
-  get google() {
-    return createGoogleGenerativeAI({
-      baseURL: safeEnv.JIXO_GOOGLE_BASE_URL || undefined,
-      apiKey: safeEnv.JIXO_GOOGLE_API_KEY,
-    });
-  },
-  get openai() {
-    return createOpenAI({
-      baseURL: safeEnv.JIXO_OPENAI_BASE_URL || undefined,
-      apiKey: safeEnv.JIXO_OPENAI_API_KEY,
-      organization: safeEnv.JIXO_OPENAI_ORGANIZATION || undefined,
-    });
-  },
-  get xai() {
-    return createXai({
-      baseURL: safeEnv.JIXO_XAI_BASE_URL || undefined,
-      apiKey: safeEnv.JIXO_XAI_API_KEY,
-    });
-  },
-  get deepinfra() {
-    return createDeepInfra({
-      baseURL: safeEnv.JIXO_DEEPINFRA_BASE_URL || undefined,
-      apiKey: safeEnv.JIXO_DEEPINFRA_API_KEY,
-    });
-  },
-});