halfcopilot 0.0.1

package/src/index.ts

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { loadConfig } from "@halfcopilot/config";
+import { ProviderRegistry } from "@halfcopilot/provider";
+import {
+  ToolRegistry,
+  createBuiltinTools,
+  PermissionChecker,
+  ToolExecutor,
+} from "@halfcopilot/tools";
+import { AgentLoop, HybridProvider, type AgentMode } from "@halfcopilot/core";
+import { MemoryStore } from "@halfcopilot/memory";
+import { SkillRegistry, createBuiltinSkills } from "@halfcopilot/skills";
+import { MCPClientManager } from "@halfcopilot/mcp";
+
+const program = new Command();
+
+program
+  .name("halfcopilot")
+  .description("HalfCopilot — Multi-model Agent Framework CLI with Hybrid Mode")
+  .version("0.0.1");
+
+function createAgent(options: {
+  model?: string;
+  provider?: string;
+  mode?: string;
+  hybrid?: boolean;
+}) {
+  const config = loadConfig();
+  const providerRegistry = new ProviderRegistry();
+  providerRegistry.createFromConfig(config);
+
+  const providerName = options.provider ?? config.defaultProvider ?? "xiaomi";
+  let provider = providerRegistry.get(providerName);
+
+  // Apply hybrid mode if requested
+  if (options.hybrid) {
+    provider = new HybridProvider(provider);
+  }
+
+  const toolRegistry = new ToolRegistry();
+  const builtinTools = createBuiltinTools();
+  builtinTools.forEach((t) => toolRegistry.register(t));
+
+  // Load skills
+  const skillRegistry = new SkillRegistry();
+  const builtinSkills = createBuiltinSkills();
+  builtinSkills.forEach((s) => skillRegistry.register(s));
+
+  const permissions = new PermissionChecker({
+    autoApproveSafe: config.permissions.autoApproveSafe,
+    allow: config.permissions.allow,
+    deny: config.permissions.deny,
+  });
+
+  const executor = new ToolExecutor(toolRegistry, permissions);
+
+  const agent = new AgentLoop({
+    provider,
+    model: options.model ?? config.defaultModel ?? "mimo-v2.5-pro",
+    tools: toolRegistry,
+    executor,
+    permissions,
+    maxTurns: config.maxTurns,
+    mode: (options.mode as AgentMode) ?? "auto",
+  });
+
+  return { agent, providerName, config, skillRegistry };
+}
+
+program
+  .command("chat")
+  .description("Start interactive chat mode")
+  .option("-m, --model <model>", "Model to use")
+  .option("-p, --provider <provider>", "Provider to use")
+  .option("--mode <mode>", "Agent mode (plan/review/act/auto)", "auto")
+  .option(
+    "--hybrid",
+    "Enable hybrid mode (text block parsing for non-tool-use models)",
+  )
+  .option("--tui", "Enable TUI mode (requires ink/React)")
+  .action(async (options) => {
+    try {
+      const { agent, providerName, config, skillRegistry } =
+        createAgent(options);
+
+      // Try to use TUI if requested
+      if (options.tui) {
+        try {
+          const { render } = await import("ink");
+          const React = await import("react");
+          const { App } = await import("./tui/app.js");
+
+          const { waitUntilExit } = render(
+            React.createElement(App, {
+              agent,
+              providerName,
+              model: options.model ?? config.defaultModel ?? "mimo-v2.5-pro",
+              mode: options.mode ?? "auto",
+            }),
+          );
+
+          await waitUntilExit();
+          return;
+        } catch {
+          // Fallback to simple CLI
+          console.log("TUI mode not available, falling back to simple mode\n");
+        }
+      }
+
+      // Simple CLI mode
+      console.log(
+        "\x1b[36m╔══════════════════════════════════════════════════╗\x1b[0m",
+      );
+      console.log(
+        "\x1b[36m║          HalfCopilot v0.0.1                      ║\x1b[0m",
+      );
+      console.log(
+        "\x1b[36m║   Multi-model Agent Framework CLI                ║\x1b[0m",
+      );
+      console.log(
+        "\x1b[36m╚══════════════════════════════════════════════════╝\x1b[0m",
+      );
+      console.log(`\x1b[32mProvider:\x1b[0m ${providerName}`);
+      console.log(
+        `\x1b[32mModel:\x1b[0m ${options.model ?? config.defaultModel ?? "mimo-v2.5-pro"}`,
+      );
+      console.log(`\x1b[32mMode:\x1b[0m ${options.mode ?? "auto"}`);
+      if (options.hybrid) {
+        console.log(`\x1b[33mHybrid Mode: Enabled\x1b[0m`);
+      }
+      console.log(
+        `\x1b[33mType your message and press Enter. Type 'exit' to quit.\x1b[0m\n`,
+      );
+
+      const readline = await import("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      const ask = () => {
+        rl.question("\x1b[32m❯ \x1b[0m", async (input) => {
+          if (
+            input.trim().toLowerCase() === "exit" ||
+            input.trim().toLowerCase() === "quit"
+          ) {
+            console.log("\x1b[33mGoodbye!\x1b[0m");
+            rl.close();
+            return;
+          }
+
+          if (input.trim() === "") {
+            ask();
+            return;
+          }
+
+          // Check for skill triggers
+          const matchedSkills = skillRegistry.findByTrigger(input);
+          if (matchedSkills.length > 0) {
+            console.log(
+              `\x1b[35m[Skills matched: ${matchedSkills.map((s) => s.name).join(", ")}]\x1b[0m`,
+            );
+          }
+
+          try {
+            for await (const event of agent.run(input)) {
+              if (event.type === "text") {
+                process.stdout.write(event.content ?? "");
+              } else if (event.type === "tool_use") {
+                console.log(`\n\x1b[35m[Tool: ${event.toolName}]\x1b[0m`);
+              } else if (event.type === "tool_result") {
+                const result = event.toolOutput ?? "";
+                const truncated =
+                  result.length > 200 ? result.slice(0, 200) + "..." : result;
+                console.log(`\x1b[36m[Result: ${truncated}]\x1b[0m`);
+              } else if (event.type === "error") {
+                console.log(`\x1b[31m[Error: ${event.error?.message}]\x1b[0m`);
+              } else if (event.type === "done") {
+                console.log("\n");
+              }
+            }
+          } catch (err) {
+            console.log(
+              `\x1b[31m[Error: ${err instanceof Error ? err.message : err}]\x1b[0m`,
+            );
+          }
+
+          ask();
+        });
+      };
+
+      ask();
+    } catch (err) {
+      console.error(
+        "\x1b[31mError:\x1b[0m",
+        err instanceof Error ? err.message : err,
+      );
+      process.exit(1);
+    }
+  });
+
+program
+  .command("run <prompt>")
+  .description("Run a single prompt and exit")
+  .option("-m, --model <model>", "Model to use")
+  .option("-p, --provider <provider>", "Provider to use")
+  .option("--mode <mode>", "Agent mode (plan/review/act/auto)", "act")
+  .option("--hybrid", "Enable hybrid mode")
+  .action(async (prompt, options) => {
+    try {
+      const { agent } = createAgent(options);
+
+      for await (const event of agent.run(prompt)) {
+        if (event.type === "text") {
+          process.stdout.write(event.content ?? "");
+        } else if (event.type === "tool_use") {
+          console.log(`\n\x1b[35m[Tool: ${event.toolName}]\x1b[0m`);
+        } else if (event.type === "tool_result") {
+          const result = event.toolOutput ?? "";
+          const truncated =
+            result.length > 200 ? result.slice(0, 200) + "..." : result;
+          console.log(`\x1b[36m[Result: ${truncated}]\x1b[0m`);
+        }
+      }
+
+      console.log("\n");
+    } catch (err) {
+      console.error(
+        "\x1b[31mError:\x1b[0m",
+        err instanceof Error ? err.message : err,
+      );
+      process.exit(1);
+    }
+  });
+
+program
+  .command("config")
+  .description("Show configuration")
+  .action(() => {
+    try {
+      const config = loadConfig();
+      console.log("\x1b[36mCurrent Configuration:\x1b[0m");
+      console.log(JSON.stringify(config, null, 2));
+    } catch (err) {
+      console.error(
+        "\x1b[31mError:\x1b[0m",
+        err instanceof Error ? err.message : err,
+      );
+    }
+  });
+
+program
+  .command("providers")
+  .description("List available providers")
+  .action(() => {
+    try {
+      const config = loadConfig();
+      const providerRegistry = new ProviderRegistry();
+      providerRegistry.createFromConfig(config);
+      console.log(
+        "\x1b[36mAvailable providers:\x1b[0m",
+        providerRegistry.list().join(", "),
+      );
+    } catch (err) {
+      console.error(
+        "\x1b[31mError:\x1b[0m",
+        err instanceof Error ? err.message : err,
+      );
+    }
+  });
+
+program
+  .command("skills")
+  .description("List available skills")
+  .action(() => {
+    try {
+      const skillRegistry = new SkillRegistry();
+      const builtinSkills = createBuiltinSkills();
+      builtinSkills.forEach((s) => skillRegistry.register(s));
+
+      console.log("\x1b[36mAvailable Skills:\x1b[0m\n");
+      for (const skill of skillRegistry.list()) {
+        console.log(`\x1b[32m${skill.name}\x1b[0m: ${skill.description}`);
+        if (skill.triggers && skill.triggers.length > 0) {
+          console.log(
+            `  Triggers: ${skill.triggers.map((t) => t.value).join(", ")}`,
+          );
+        }
+        console.log();
+      }
+    } catch (err) {
+      console.error(
+        "\x1b[31mError:\x1b[0m",
+        err instanceof Error ? err.message : err,
+      );
+    }
+  });
+
+program
+  .command("doctor")
+  .description("Check configuration and environment")
+  .action(() => {
+    console.log("\x1b[36mHalfCopilot Doctor\x1b[0m\n");
+
+    try {
+      const config = loadConfig();
+      console.log("\x1b[32m✓\x1b[0m Configuration loaded successfully");
+
+      const providerRegistry = new ProviderRegistry();
+      providerRegistry.createFromConfig(config);
+      console.log(
+        `\x1b[32m✓\x1b[0m Providers: ${providerRegistry.list().join(", ")}`,
+      );
+
+      console.log(
+        `\x1b[32m✓\x1b[0m Default provider: ${config.defaultProvider}`,
+      );
+      console.log(`\x1b[32m✓\x1b[0m Default model: ${config.defaultModel}`);
+
+      const toolRegistry = new ToolRegistry();
+      const builtinTools = createBuiltinTools();
+      builtinTools.forEach((t) => toolRegistry.register(t));
+      console.log(
+        `\x1b[32m✓\x1b[0m Built-in tools: ${toolRegistry.list().join(", ")}`,
+      );
+
+      const skillRegistry = new SkillRegistry();
+      const builtinSkills = createBuiltinSkills();
+      builtinSkills.forEach((s) => skillRegistry.register(s));
+      console.log(
+        `\x1b[32m✓\x1b[0m Skills: ${skillRegistry
+          .list()
+          .map((s) => s.name)
+          .join(", ")}`,
+      );
+
+      console.log("\n\x1b[32mAll checks passed!\x1b[0m");
+    } catch (err) {
+      console.error(
+        "\x1b[31m✗ Error:\x1b[0m",
+        err instanceof Error ? err.message : err,
+      );
+    }
+  });
+
+program.parse();

package/src/tui/app.tsx

@@ -0,0 +1,160 @@
+import React, { useState, useCallback, useEffect } from "react";
+import { Box, Text, useApp } from "ink";
+import {
+  StatusBar,
+  ChatView,
+  InputField,
+  ToolApproval,
+} from "./components/index.js";
+import type { AgentLoop, AgentEvent } from "@halfcopilot/core";
+
+interface Message {
+  role: "user" | "assistant" | "system" | "tool";
+  content: string;
+  toolName?: string;
+}
+
+interface AppProps {
+  agent: AgentLoop;
+  providerName: string;
+  model: string;
+  mode: string;
+}
+
+export const App: React.FC<AppProps> = ({
+  agent,
+  providerName,
+  model,
+  mode,
+}) => {
+  const { exit } = useApp();
+  const [messages, setMessages] = useState<Message[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [currentMode, setCurrentMode] = useState(mode);
+  const [tokenUsage, setTokenUsage] = useState({
+    inputTokens: 0,
+    outputTokens: 0,
+  });
+  const [turnCount, setTurnCount] = useState(0);
+  const [lastResponseTime, setLastResponseTime] = useState<number>(0);
+  const [pendingApproval, setPendingApproval] = useState<{
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    permissionLevel?: "SAFE" | "WARN" | "UNSAFE";
+  } | null>(null);
+
+  const handleSubmit = useCallback(
+    async (input: string) => {
+      if (input.toLowerCase() === "exit" || input.toLowerCase() === "quit") {
+        exit();
+        return;
+      }
+
+      setMessages((prev) => [...prev, { role: "user", content: input }]);
+      setIsLoading(true);
+      setTurnCount((prev) => prev + 1);
+
+      try {
+        let fullText = "";
+        const respStart = Date.now();
+        for await (const event of agent.run(input)) {
+          switch (event.type) {
+            case "text":
+              fullText += event.content ?? "";
+              break;
+            case "tool_use":
+              setMessages((prev) => [
+                ...prev,
+                {
+                  role: "tool",
+                  content: JSON.stringify(event.toolInput),
+                  toolName: event.toolName ?? "",
+                },
+              ]);
+              setPendingApproval({
+                toolName: event.toolName ?? "",
+                toolInput: event.toolInput ?? {},
+                permissionLevel: "WARN",
+              });
+              break;
+            case "tool_result":
+              setPendingApproval(null);
+              setMessages((prev) => [
+                ...prev,
+                {
+                  role: "tool",
+                  content: event.toolOutput ?? "",
+                  toolName: event.toolName,
+                },
+              ]);
+              break;
+            case "done":
+              setLastResponseTime(Date.now() - respStart);
+              if (event.usage) {
+                setTokenUsage((prev) => ({
+                  inputTokens: prev.inputTokens + event.usage!.inputTokens,
+                  outputTokens: prev.outputTokens + event.usage!.outputTokens,
+                }));
+              }
+              break;
+            case "error":
+              setMessages((prev) => [
+                ...prev,
+                {
+                  role: "system",
+                  content: `Error: ${event.error?.message}`,
+                },
+              ]);
+              break;
+          }
+        }
+
+        if (fullText) {
+          setMessages((prev) => [
+            ...prev,
+            { role: "assistant", content: fullText },
+          ]);
+        }
+      } catch (err) {
+        setMessages((prev) => [
+          ...prev,
+          {
+            role: "system",
+            content: `Error: ${err instanceof Error ? err.message : err}`,
+          },
+        ]);
+      } finally {
+        setIsLoading(false);
+        setPendingApproval(null);
+      }
+    },
+    [agent, exit],
+  );
+
+  return (
+    <Box flexDirection="column" height="100%">
+      <StatusBar
+        provider={providerName}
+        model={model}
+        mode={currentMode}
+        tokenUsage={tokenUsage}
+        turnInfo={{ current: turnCount, max: 20 }}
+        responseTime={lastResponseTime}
+      />
+      <Box flexDirection="column" flexGrow={1}>
+        <ChatView messages={messages} />
+      </Box>
+      {pendingApproval ? (
+        <ToolApproval
+          toolName={pendingApproval.toolName}
+          toolInput={pendingApproval.toolInput}
+          permissionLevel={pendingApproval.permissionLevel}
+          onApprove={() => setPendingApproval(null)}
+          onReject={() => setPendingApproval(null)}
+        />
+      ) : (
+        <InputField onSubmit={handleSubmit} isLoading={isLoading} />
+      )}
+    </Box>
+  );
+};

package/src/tui/components/ChatView.tsx

@@ -0,0 +1,130 @@
+import React, { Fragment } from "react";
+import { Box, Text } from "ink";
+
+interface Message {
+  role: "user" | "assistant" | "system" | "tool";
+  content: string;
+  toolName?: string;
+}
+
+interface ChatViewProps {
+  messages: Message[];
+}
+
+function CodeBlock({ code, language }: { code: string; language?: string }) {
+  const lines = code.split("\n");
+  return (
+    <Box flexDirection="column" marginLeft={2} marginY={0}>
+      {language && (
+        <Box>
+          <Text color="gray">{language}</Text>
+        </Box>
+      )}
+      {lines.map((line, i) => (
+        <Box key={i}>
+          <Text color="gray">│ </Text>
+          <Text color="white">{line}</Text>
+        </Box>
+      ))}
+    </Box>
+  );
+}
+
+function formatContent(content: string): React.ReactNode[] {
+  const parts = content.split(/(```[\s\S]*?```)/);
+  const nodes: React.ReactNode[] = [];
+  let key = 0;
+
+  for (const part of parts) {
+    if (part.startsWith("```")) {
+      const code = part
+        .replace(/```(\w*)\n?/, (_, lang) => {
+          nodes.push(<CodeBlock key={key++} code={""} language={lang} />);
+          return "";
+        })
+        .replace(/```$/, "");
+      const match = part.match(/```(\w*)\n?([\s\S]*?)```/);
+      if (match) {
+        nodes.push(
+          <CodeBlock
+            key={key++}
+            code={match[2]}
+            language={match[1] || undefined}
+          />,
+        );
+      }
+    } else if (part) {
+      nodes.push(<Text key={key++}>{part}</Text>);
+    }
+  }
+
+  if (nodes.length === 0) {
+    nodes.push(<Text key={0}>{content}</Text>);
+  }
+  return nodes;
+}
+
+export const ChatView: React.FC<ChatViewProps> = ({ messages }) => {
+  // Group consecutive same-role messages
+  const grouped: { role: Message["role"]; contents: Message[] }[] = [];
+  for (const msg of messages) {
+    const last = grouped[grouped.length - 1];
+    if (last && last.role === msg.role && msg.role !== "tool") {
+      last.contents.push(msg);
+    } else {
+      grouped.push({ role: msg.role, contents: [msg] });
+    }
+  }
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      {grouped.map((group, gi) => (
+        <Box key={gi} marginBottom={1} flexDirection="column">
+          {group.role === "user" && (
+            <Box>
+              <Text color="green" bold>
+                {"❯ "}
+              </Text>
+              <Text color="white">{group.contents[0].content}</Text>
+            </Box>
+          )}
+          {group.role === "assistant" && (
+            <Box flexDirection="column">
+              <Box marginBottom={0}>
+                <Text color="blue" bold>
+                  {"● "}
+                </Text>
+                {group.contents.map((msg, i) => (
+                  <Fragment key={i}>{formatContent(msg.content)}</Fragment>
+                ))}
+              </Box>
+            </Box>
+          )}
+          {group.role === "tool" && (
+            <Box flexDirection="column">
+              {group.contents.map((msg, i) => (
+                <Box key={i}>
+                  <Text color="cyan" bold>
+                    {"🔧 "}
+                  </Text>
+                  <Text color="cyan">[{msg.toolName}] </Text>
+                  <Text color="gray">
+                    {msg.content.slice(0, 120)}
+                    {msg.content.length > 120 ? "..." : ""}
+                  </Text>
+                </Box>
+              ))}
+            </Box>
+          )}
+          {group.role === "system" && (
+            <Box>
+              <Text color="gray">
+                {group.contents.map((m) => m.content).join("\n")}
+              </Text>
+            </Box>
+          )}
+        </Box>
+      ))}
+    </Box>
+  );
+};

package/src/tui/components/InputField.tsx

@@ -0,0 +1,41 @@
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+
+interface InputFieldProps {
+  onSubmit: (input: string) => void;
+  isLoading?: boolean;
+}
+
+export const InputField: React.FC<InputFieldProps> = ({
+  onSubmit,
+  isLoading,
+}) => {
+  const [value, setValue] = useState("");
+
+  useInput((input, key) => {
+    if (key.return) {
+      if (value.trim()) {
+        onSubmit(value.trim());
+        setValue("");
+      }
+    } else if (key.backspace || key.delete) {
+      setValue((prev) => prev.slice(0, -1));
+    } else if (input && !key.ctrl && !key.meta) {
+      setValue((prev) => prev + input);
+    }
+  });
+
+  return (
+    <Box borderStyle="single" borderColor="green" paddingX={1}>
+      <Text color="green" bold>
+        {"❯ "}
+      </Text>
+      <Text color="white">{value}</Text>
+      {isLoading ? (
+        <Text color="yellow"> ⏳</Text>
+      ) : (
+        <Text color="gray">█</Text>
+      )}
+    </Box>
+  );
+};