karnel-termux 0.0.1

package/karnel/tools/ai/kimchi-code/install.sh

@@ -0,0 +1,221 @@
+#!/usr/bin/env bash
+
+# Kimchi CLI - Karnel installer
+# Usa o sistema de import padronizado do Karnel (bootstrap.sh)
+import "@/utils/log"
+import "@/utils/colors"
+
+export KARNEL_CACHE="${KARNEL_CACHE:-$HOME/.cache/karnel}"
+export PREFIX="${PREFIX:-/data/data/com.termux/files/usr}"
+
+LOG_FILE="$KARNEL_CACHE/install_ai.log"
+KIMCHI_DATA_DIR="$HOME/.local/share/karnel-data/kimchi"
+KIMCHI_BIN_PATH="$KIMCHI_DATA_DIR/kimchi"
+
+_get_latest_kimchi_version() {
+  curl -fsSL https://api.github.com/repos/getkimchi/kimchi/releases/latest 2>/dev/null |
+    grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/'
+}
+
+_kimchi_download_binary() {
+  loading "Downloading Kimchi CLI" _kimchi_download_binary_impl
+}
+
+_kimchi_download_binary_impl() {
+  local latest_version
+  latest_version=$(_get_latest_kimchi_version)
+  if [ -z "$latest_version" ]; then
+    log_error "Failed to fetch latest Kimchi version"
+    return 1
+  fi
+
+  mkdir -p "$KIMCHI_DATA_DIR"
+
+  local arch
+  arch=$(uname -m)
+  local kimchi_arch=""
+  case "$arch" in
+    aarch64|arm64) kimchi_arch="arm64" ;;
+    x86_64) kimchi_arch="amd64" ;;
+    *) kimchi_arch="arm64" ;;
+  esac
+
+  local tarball="kimchi_linux_${kimchi_arch}.tar.gz"
+  local download_url="https://github.com/getkimchi/kimchi/releases/download/${latest_version}/${tarball}"
+
+  if ! curl -fsSL "$download_url" -o "$KIMCHI_DATA_DIR/$tarball" &>>"$LOG_FILE"; then
+    log_error "Failed to download Kimchi binary"
+    return 1
+  fi
+
+  if ! tar -zxf "$KIMCHI_DATA_DIR/$tarball" -C "$KIMCHI_DATA_DIR" &>>"$LOG_FILE"; then
+    log_error "Failed to extract Kimchi binary"
+    return 1
+  fi
+
+  rm -f "$KIMCHI_DATA_DIR/$tarball"
+
+  # Find the kimchi binary (may be named kimchi or kimchi-linux-*)
+  local kimchi_bin=""
+  if [ -f "$KIMCHI_BIN_PATH" ]; then
+    kimchi_bin="$KIMCHI_BIN_PATH"
+  else
+    kimchi_bin=$(find "$KIMCHI_DATA_DIR" -name "kimchi*" -type f -executable 2>/dev/null | head -1)
+  fi
+
+  if [ -z "$kimchi_bin" ] || [ ! -f "$kimchi_bin" ]; then
+    log_error "Kimchi binary not found after extraction"
+    return 1
+  fi
+
+  # Rename if needed
+  if [ "$kimchi_bin" != "$KIMCHI_BIN_PATH" ]; then
+    mv "$kimchi_bin" "$KIMCHI_BIN_PATH"
+  fi
+
+  chmod +x "$KIMCHI_BIN_PATH"
+
+  # Validacao: confirma que o binario existe e e executavel
+  if [ ! -x "$KIMCHI_BIN_PATH" ]; then
+    log_error "Kimchi binary is not executable after setup"
+    return 1
+  fi
+
+  return 0
+}
+
+_install_kimchi_wrapper() {
+  loading "Creating Kimchi wrapper" _install_kimchi_wrapper_impl
+}
+
+_install_kimchi_wrapper_impl() {
+  local wrapper_path="$PREFIX/bin/kimchi"
+
+  # Cria wrapper com CAMINHO ABSOLUTO para evitar depender de variaveis em runtime.
+  # O caminho e resolvido no momento da instalacao (KIMCHI_BIN_PATH = $HOME/.local/share/karnel-data/kimchi/kimchi).
+  cat > "$wrapper_path" << WRAPPER
+#!/data/data/com.termux/files/usr/bin/bash
+# Kimchi CLI wrapper — gerado pelo Karnel
+# Caminho absoluto do binario (resolvido na instalacao)
+KIMCHI_BIN="${KIMCHI_BIN_PATH}"
+
+if [ "\$#" -eq 0 ]; then
+  exec "\$KIMCHI_BIN"
+elif [ "\$1" = "-i" ] || [ "\$1" = "--interactive" ]; then
+  # Kimchi nao tem flag -i; modo interativo e o padrao
+  exec "\$KIMCHI_BIN"
+else
+  exec "\$KIMCHI_BIN" "\$@"
+fi
+WRAPPER
+  chmod +x "$wrapper_path"
+
+  # Valida que o wrapper foi criado corretamente
+  if [ ! -f "$wrapper_path" ]; then
+    log_error "Failed to create kimchi wrapper at $wrapper_path"
+    return 1
+  fi
+
+  # Verifica se o caminho no wrapper esta correto (nao pode ser "/kimchi" na raiz)
+  if grep -q 'KIMCHI_BIN="/kimchi"' "$wrapper_path" 2>/dev/null; then
+    log_error "Kimchi wrapper has invalid path (/kimchi) — KIMCHI_DATA_DIR was empty"
+    rm -f "$wrapper_path"
+    return 1
+  fi
+
+  # Kimchi é glibc — precisa rodar dentro do proot ubuntu no Termux
+  if ! command -v proot-distro &>/dev/null; then
+    pkg install proot-distro -y &>>"$LOG_FILE" || true
+  fi
+
+  # Rewrite wrapper to use proot-distro
+  cat > "$wrapper_path" << 'PROOT_WRAPPER'
+#!/data/data/com.termux/files/usr/bin/bash
+KIMCHI_DIR="/data/data/com.termux/files/home/.local/share/karnel-data/kimchi"
+KIMCHI_BIN="$KIMCHI_DIR/kimchi"
+
+ARGS=""
+for arg in "$@"; do
+  ARGS="$ARGS '$arg'"
+done
+
+exec proot-distro login ubuntu -- bash -c "
+  export HOME=/root
+  mkdir -p /root/.local/share/kimchi
+  cp -r $KIMCHI_DIR/share/kimchi/* /root/.local/share/kimchi/ 2>/dev/null || true
+  $KIMCHI_BIN $ARGS
+" 2>&1
+PROOT_WRAPPER
+  chmod +x "$wrapper_path"
+
+  return 0
+}
+
+install_kimchi_code() {
+  # Verificacao dupla: binario REAL (nao wrapper) + comando no PATH
+  if [ -f "$KIMCHI_BIN_PATH" ] && command -v kimchi &>/dev/null; then
+    log_info "Kimchi is already installed"
+    return 2
+  fi
+
+  log_info "Installing Kimchi CLI..."
+
+  mkdir -p "$(dirname "$LOG_FILE")" "$KIMCHI_DATA_DIR"
+
+  _kimchi_download_binary || return 1
+  _install_kimchi_wrapper || return 1
+
+  # Validacao final: command -v + verificacao de que nao e stub
+  if command -v kimchi &>/dev/null; then
+    local bin_path
+    bin_path=$(command -v kimchi)
+    if [ -f "$bin_path" ] && grep -q "KIMCHI_BIN=" "$bin_path" 2>/dev/null; then
+      log_success "Kimchi CLI installed"
+      log_info "Usage: ${D_CYAN}kimchi${NC} to launch the interactive TUI"
+      log_info "Setup: ${D_CYAN}kimchi setup${NC} for first-time configuration"
+      log_info "Docs:  ${D_CYAN}https://docs.kimchi.dev${NC}"
+      return 0
+    fi
+  fi
+
+  log_error "Kimchi CLI installation failed: binary not found or invalid"
+  rm -f "$PREFIX/bin/kimchi" 2>/dev/null
+  return 1
+}
+
+uninstall_kimchi_code() {
+  log_info "Uninstalling Kimchi CLI..."
+  mkdir -p "$(dirname "$LOG_FILE")"
+
+  rm -f "$PREFIX/bin/kimchi" 2>/dev/null
+  rm -rf "$KIMCHI_DATA_DIR" 2>/dev/null
+
+  log_success "Kimchi CLI uninstalled"
+  return 0
+}
+
+update_kimchi_code() {
+  log_info "Updating Kimchi CLI..."
+  mkdir -p "$(dirname "$LOG_FILE")"
+
+  rm -rf "$KIMCHI_DATA_DIR" 2>/dev/null
+  mkdir -p "$KIMCHI_DATA_DIR"
+
+  _kimchi_download_binary || {
+    log_error "Failed to update Kimchi CLI"
+    return 1
+  }
+
+  _install_kimchi_wrapper || {
+    log_error "Failed to update Kimchi CLI wrapper"
+    return 1
+  }
+
+  log_success "Kimchi CLI updated"
+  return 0
+}
+
+reinstall_kimchi_code() {
+  uninstall_kimchi_code
+  install_kimchi_code
+}

package/karnel/tools/ai/kimi-code/README.md

@@ -0,0 +1,45 @@
+# Kimi Code
+
+Kimi Code CLI — The Starting Point for Next-Gen Agents
+
+**Package:** @moonshot-ai/kimi-code
+**Author:** israel marques
+**Repository:** https://github.com/israelmarques1024-dotcom/karnel-termux
+**Official:** https://github.com/MoonshotAI/kimi-code 
+**Type:** AI CLI tool (npm global package)
+**License:** MIT
+
+# Description
+
+Kimi Code CLI is an AI coding agent that runs in your terminal — it can read and edit code, run shell commands, search files, fetch web pages, and choose the next step based on the feedback it receives. It works out of the box with Moonshot AI’s Kimi models and can also be configured to use other compatible providers.
+
+## Dependencies
+
+- Node.js LTS (nodejs-lts)
+- npm
+- git, ripgrep
+
+## Install
+
+```bash
+karnel install ai --kimi-code
+```
+
+## Uninstall
+
+```bash
+karnel uninstall ai --kimi-code
+```
+
+## Update
+
+```bash
+karnel update ai --kimi-code
+```
+
+## Notes
+
+- Installed as a global npm package: `@moonshot-ai/kimi-code`
+- Command: `kimi`
+- Requires authentication with Kimi API key or OAuth
+

package/karnel/tools/ai/kimi-code/install.sh

@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+
+import "@/utils/log"
+
+LOG_FILE="$KARNEL_CACHE/install_ai.log"
+
+_kimi_code_dependencies() {
+  loading "Installing dependencies" _kimi_code_dependencies_impl
+}
+
+_kimi_code_dependencies_impl() {
+  declare -A DEPS=(
+    ["nodejs-lts"]="node"
+    ["git"]="git"
+    ["ripgrep"]="rg"
+  )
+
+  local pkg_name bin_name
+  for pkg_name in "${!DEPS[@]}"; do
+    bin_name="${DEPS[$pkg_name]}"
+    if ! command -v "$bin_name" &>/dev/null; then
+      if ! pkg install "$pkg_name" -y &>>"$LOG_FILE"; then
+        log_error "Failed to install $pkg_name"
+        return 1
+      fi
+    fi
+  done
+
+  return 0
+}
+
+_install_kimi_code_npm() {
+  loading "Installing Kimi Code" _install_kimi_code_npm_impl
+}
+
+_install_kimi_code_npm_impl() {
+  if ! npm install -g @moonshot-ai/kimi-code &>>"$LOG_FILE"; then
+    log_error "Failed to install Kimi Code"
+    return 1
+  fi
+
+  return 0
+}
+
+install_kimi_code() {
+  if command -v kimi &>/dev/null; then
+    log_info "Kimi Code is already installed"
+    return 2
+  fi
+
+  log_info "Installing Kimi Code..."
+
+  mkdir -p "$(dirname "$LOG_FILE")"
+
+  _kimi_code_dependencies || return 1
+  _install_kimi_code_npm || return 1
+
+  log_success "Kimi Code installed successfully"
+  return 0
+}
+
+uninstall_kimi_code() {
+  if ! command -v kimi &>/dev/null; then
+    log_success "Kimi Code is not installed"
+    return 2
+  fi
+
+  log_info "Uninstalling Kimi Code..."
+  mkdir -p "$(dirname "$LOG_FILE")"
+
+  loading "Removing Kimi Code" _uninstall_kimi_code_impl
+
+  log_success "Kimi Code uninstalled successfully"
+  return 0
+}
+
+_uninstall_kimi_code_impl() {
+  if ! npm uninstall -g @moonshot-ai/kimi-code &>>"$LOG_FILE"; then
+    log_error "Failed to uninstall Kimi Code"
+    return 1
+  fi
+  return 0
+}
+
+update_kimi_code() {
+  if ! command -v kimi &>/dev/null; then
+    log_error "Kimi Code is not installed"
+    return 1
+  fi
+
+  log_info "Updating Kimi Code..."
+  mkdir -p "$(dirname "$LOG_FILE")"
+
+  loading "Updating Kimi Code" _update_kimi_code_impl
+
+  log_success "Kimi Code updated successfully"
+  return 0
+}
+
+_update_kimi_code_impl() {
+  if ! npm update -g @moonshot-ai/kimi-code &>>"$LOG_FILE"; then
+    log_error "Failed to update Kimi Code"
+    return 1
+  fi
+  return 0
+}
+
+reinstall_kimi_code() {
+  uninstall_kimi_code
+  install_kimi_code
+}

package/karnel/tools/ai/kiro/README.md

@@ -0,0 +1,17 @@
+# Kiro
+
+> AI-powered coding assistant from Amazon/AWS.
+
+Kiro is an AI coding assistant that helps with code generation, debugging, and development tasks. It provides an interactive terminal interface with multi-model support.
+
+**Install:** `karnel install ai --kiro`
+**Command:** `kiro` or `kiro-cli`
+**Docs:** https://kiro.dev
+
+## Features
+
+- AI-powered code generation and editing
+- Multi-model support
+- Interactive terminal interface
+- Code analysis and debugging
+- Project-aware context

package/karnel/tools/ai/kiro/install.sh

@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+
+import "@/utils/log"
+import "@/utils/colors"
+
+LOG_FILE="$KARNEL_CACHE/install_ai.log"
+
+install_kiro() {
+  if command -v kiro &>/dev/null || command -v kiro-cli &>/dev/null; then
+    log_info "Kiro is already installed"
+    return 2
+  fi
+
+  log_info "Installing Kiro CLI..."
+
+  # Try the official installer first
+  log_info "Running official Kiro installer..."
+  if echo "y" | curl -fsSL https://cli.kiro.dev/install 2>/dev/null | bash 2>>"$LOG_FILE"; then
+    if command -v kiro &>/dev/null || command -v kiro-cli &>/dev/null; then
+      log_success "Kiro installed successfully"
+      return 0
+    fi
+  fi
+
+  # Fallback: download directly from release server
+  log_warn "Official installer failed, trying direct download..."
+
+  local arch
+  arch=$(uname -m)
+  local manifest
+  manifest=$(curl -fsSL "https://prod.download.cli.kiro.dev/stable/latest/manifest.json" 2>/dev/null)
+
+  if [[ -z "$manifest" ]]; then
+    log_error "Failed to fetch Kiro manifest"
+    return 1
+  fi
+
+  # Find the arm64 linux package (prefer musl for Termux compatibility)
+  local download_path
+  # Try musl first (statically linked, works without glibc)
+  download_path=$(echo "$manifest" | python3 -c "
+import json,sys
+d=json.load(sys.stdin)
+for p in d['packages']:
+    if p.get('architecture')=='aarch64' and p.get('os')=='linux' and 'tar' in p.get('fileType','').lower() and 'xz' not in p.get('fileType','').lower() and 'zst' not in p.get('fileType','').lower() and 'musl' in p.get('download',''):
+        print(p['download'])
+        break
+" 2>/dev/null)
+  # Fallback to glibc version
+  if [[ -z "$download_path" ]]; then
+    download_path=$(echo "$manifest" | python3 -c "
+import json,sys
+d=json.load(sys.stdin)
+for p in d['packages']:
+    if p.get('architecture')=='aarch64' and p.get('os')=='linux' and 'tar' in p.get('fileType','').lower() and 'xz' not in p.get('fileType','').lower() and 'zst' not in p.get('fileType','').lower() and 'musl' not in p.get('download',''):
+        print(p['download'])
+        break
+" 2>/dev/null)
+  fi
+
+  if [[ -z "$download_path" ]]; then
+    log_error "No compatible package found for $arch"
+    return 1
+  fi
+
+  local tmpdir
+  tmpdir=$(mktemp -d)
+  log_info "Downloading Kiro (this may take a while)..."
+
+  if curl -fsSL --connect-timeout 15 --max-time 300 \
+    "https://prod.download.cli.kiro.dev/stable/$download_path" \
+    -o "$tmpdir/kiro.tar.gz" 2>>"$LOG_FILE"; then
+
+    if tar xzf "$tmpdir/kiro.tar.gz" -C "$tmpdir" 2>>"$LOG_FILE"; then
+      local bin_path
+      bin_path=$(find "$tmpdir" -name "kiro-cli" -type f -executable 2>/dev/null | head -1)
+      if [[ -z "$bin_path" ]]; then
+        bin_path=$(find "$tmpdir" -name "kiro*" -type f -executable 2>/dev/null | head -1)
+      fi
+      if [[ -n "$bin_path" ]]; then
+        rm -f "$PREFIX/bin/kiro" "$PREFIX/bin/kiro-cli"
+        cp "$bin_path" "$PREFIX/bin/kiro-cli"
+        chmod +x "$PREFIX/bin/kiro-cli"
+        # Create symlink for convenience
+        ln -sf "$PREFIX/bin/kiro-cli" "$PREFIX/bin/kiro"
+        rm -rf "$tmpdir"
+        if command -v kiro-cli &>/dev/null || command -v kiro &>/dev/null; then
+          log_success "Kiro installed from direct download"
+          return 0
+        fi
+        # Binary exists but can't execute (missing glibc)
+        if [[ -f "$PREFIX/bin/kiro-cli" ]]; then
+          log_warn "Kiro binary installed but requires glibc to run"
+          log_info "Install glibc: ${D_CYAN}pkg install glibc-repo glibc${NC}"
+          log_info "Or use proot: ${D_CYAN}proot-distro install ubuntu${NC}"
+          return 0
+        fi
+      fi
+    fi
+  fi
+
+  rm -rf "$tmpdir"
+  log_error "Failed to install Kiro"
+  log_info "You can try manually: curl -fsSL https://cli.kiro.dev/install | bash"
+  return 1
+}
+
+uninstall_kiro() {
+  if ! command -v kiro &>/dev/null && ! command -v kiro-cli &>/dev/null; then
+    log_info "Kiro is not installed"
+    return 0
+  fi
+
+  log_info "Uninstalling Kiro..."
+  rm -f "$PREFIX/bin/kiro" "$PREFIX/bin/kiro-cli"
+  log_success "Kiro uninstalled"
+  return 0
+}
+
+update_kiro() {
+  if ! command -v kiro &>/dev/null && ! command -v kiro-cli &>/dev/null; then
+    log_info "Kiro is not installed"
+    return 0
+  fi
+
+  log_info "Updating Kiro..."
+  uninstall_kiro
+  install_kiro
+}
+
+reinstall_kiro() {
+  uninstall_kiro
+  install_kiro
+}

package/karnel/tools/ai/mimocode/README.md

@@ -0,0 +1,43 @@
+# MiMoCode
+
+Xiaomi's AI coding agent — fast, local, and open-source
+
+**Package:** mimocode  
+**Author:** israel marques  
+**Repository:** https://github.com/israelmarques1024-dotcom/karnel-termux  
+**Official:** https://github.com/XiaomiMiMo/MiMo-Code  
+**Type:** AI coding agent (Binary + glibc bootstrapper)  
+**License:** MIT
+
+## Description
+
+MiMo Code is Xiaomi's AI coding agent — fast, local, and open-source. It provides intelligent code completion, refactoring suggestions, and natural language code generation directly in your terminal.
+
+## Dependencies
+
+- glibc-repo, glibc, clang, curl, tar
+
+## Install
+
+```bash
+karnel install ai --mimocode
+```
+
+## Uninstall
+
+```bash
+karnel uninstall ai --mimocode
+```
+
+## Update
+
+```bash
+karnel update ai --mimocode
+```
+
+## Notes
+
+- Native installation requires `glibc-repo`, `glibc`, `clang`, and other dependencies (installed automatically)
+- The real binary is stored in `~/.local/share/karnel-data/mimocode/`
+- A small C bootstrapper (`mimocode_helper.c`) handles ELF loading via the glibc dynamic linker
+- Data directory: `~/.local/share/karnel-data/mimocode/`

package/karnel/tools/ai/mimocode/bin/mimo

@@ -0,0 +1,28 @@
+#!/data/data/com.termux/files/usr/bin/bash
+
+UBUNTU_ROOTFS="__UBUNTU_ROOTFS__"
+
+EXCLUDE_REGEX="^(PATH|LD_PRELOAD|LD_LIBRARY_PATH|PREFIX|HOME|PWD|OLDPWD|SHELL|IFS|_|SHLVL|PROMPT_COMMAND|TERMCAP|LS_COLORS|TERM)="
+
+ENV_ARGS=()
+while IFS= read -r line; do
+	if [[ -n "$line" && ! "$line" =~ $EXCLUDE_REGEX ]]; then
+		ENV_ARGS+=("--env" "$line")
+	fi
+done < <(env)
+
+ENV_ARGS+=(
+	"--env" "SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt"
+	"--env" "TERM=$TERM"
+	"--env" "HOME=/root"
+)
+
+unset LD_PRELOAD
+proot-distro login \
+	"${ENV_ARGS[@]}" \
+	--termux-home \
+	--shared-tmp \
+	--bind "$UBUNTU_ROOTFS/root/.mimocode:/root/.mimocode" \
+	--work-dir "$PWD" \
+	ubuntu \
+	-- /root/.mimocode/bin/mimo "$@"

package/karnel/tools/ai/mimocode/helper/mimocode_helper.c

@@ -0,0 +1,47 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <libgen.h>
+#include <limits.h>
+#include <stdio.h>
+
+int main(int argc, char** argv) {
+    unsetenv("LD_PRELOAD");
+    unsetenv("LD_LIBRARY_PATH");
+
+    setenv("GODEBUG", "netdns=cgo", 1);
+    setenv("SSL_CERT_FILE", "/data/data/com.termux/files/usr/etc/tls/cert.pem", 1);
+
+    char exec_path[PATH_MAX];
+    ssize_t len = readlink("/proc/self/exe", exec_path, sizeof(exec_path) - 1);
+    if (len == -1) {
+        return 1;
+    }
+    exec_path[len] = '\0';
+    char* dir = dirname(exec_path);
+
+    char* loader = "/data/data/com.termux/files/usr/glibc/lib/ld-linux-aarch64.so.1";
+    char real_bin[] = "/data/data/com.termux/files/home/.local/share/karnel-data/mimocode/mimocode";
+    char lib_path[] = "/data/data/com.termux/files/usr/glibc/lib";
+
+    char** new_argv = malloc((argc + 4) * sizeof(char*));
+    if (!new_argv) {
+        return 1;
+    }
+
+    new_argv[0] = loader;
+    new_argv[1] = "--library-path";
+    new_argv[2] = lib_path;
+    new_argv[3] = real_bin;
+
+    for (int i = 1; i < argc; i++) {
+        new_argv[i + 3] = argv[i];
+    }
+    new_argv[argc + 3] = NULL;
+
+    execv(loader, new_argv);
+
+    perror("execv");
+    free(new_argv);
+    return 1;
+}