@hams-ai/cli 1.0.0

package/API_PATCH.py

@@ -0,0 +1,43 @@
+"""
+PATCH — tambahkan ini ke agent/api.py
+======================================
+
+Tambahkan 3 hal:
+  1. import os, argparse  (di bagian atas file)
+  2. Endpoint /health     (di dalam FastAPI app)
+  3. Argparse --port      (di bagian if __name__ == "__main__")
+"""
+
+import os
+import argparse
+
+# ── 1. Tambahkan endpoint ini ke FastAPI app kamu ────────────────────────────
+@app.get("/health")
+def health():
+    return {"status": "ok", "agent": "hams.ai", "version": "1.0.0"}
+
+
+# ── 2. Ganti bagian if __name__ == "__main__" dengan ini ─────────────────────
+if __name__ == "__main__":
+    import uvicorn
+
+    parser = argparse.ArgumentParser(description="hams.ai API Server")
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=int(os.environ.get("AGENT_PORT", 8000)),
+        help="Port to run the server on",
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="127.0.0.1",
+    )
+    args = parser.parse_args()
+
+    uvicorn.run(
+        app,
+        host=args.host,
+        port=args.port,
+        log_level="warning",   # suppress noise saat dipakai dari CLI
+    )

package/README.md

@@ -0,0 +1,84 @@
+# @hams-ai/cli
+
+Official CLI for [hams.ai](https://hams.ai) — AI Coding Agent.
+
+## Install
+
+```powershell
+npm install -g @hams-ai/cli
+```
+
+## Prerequisites
+
+- **Node.js** 16+ — [nodejs.org](https://nodejs.org)
+- **Python** 3.8+ — [python.org](https://python.org)
+- **hams.ai** project folder (the Python agent)
+
+## Setup
+
+After install, tell the CLI where your hams.ai project lives:
+
+**PowerShell:**
+```powershell
+$env:HAMS_PATH = "C:\Users\kamu\hams.ai"
+```
+
+**Linux / Mac:**
+```bash
+export HAMS_PATH="/home/kamu/hams.ai"
+```
+
+To make it permanent, add the line above to your shell profile (`$PROFILE` on PowerShell, `~/.bashrc` or `~/.zshrc` on Linux/Mac).
+
+## Usage
+
+```powershell
+# Interactive chat (default)
+hams
+
+# Run a single task
+hams run "buatkan REST API dengan FastAPI untuk CRUD user"
+
+# List available tools
+hams tools
+
+# Check if backend is running
+hams status
+
+# Show Python backend output (debug)
+hams --verbose
+
+# Use custom port
+hams --port 9000
+```
+
+## How it works
+
+```
+hams (CLI)
+  └── finds Python on your system
+  └── auto-installs requirements.txt (first time)
+  └── spawns agent/api.py --port 8000
+  └── waits for /health to respond
+  └── sends your tasks via POST /run/stream
+  └── streams response back to terminal
+  └── shuts down Python when you exit
+```
+
+## Development (local install)
+
+```powershell
+# Di dalam folder cli/
+npm install
+npm link
+
+# Sekarang "hams" tersedia di terminal
+hams
+```
+
+## Publishing
+
+```powershell
+npm login
+npm publish --access public
+```

package/bin/hams.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ *  ██╗  ██╗ █████╗ ███╗   ███╗███████╗   █████╗ ██╗
+ *  ██║  ██║██╔══██╗████╗ ████║██╔════╝  ██╔══██╗██║
+ *  ███████║███████║██╔████╔██║███████╗  ███████║██║
+ *  ██╔══██║██╔══██║██║╚██╔╝██║╚════██║  ██╔══██║██║
+ *  ██║  ██║██║  ██║██║ ╚═╝ ██║███████║  ██║  ██║██║
+ *  ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝  ╚═╝  ╚═╝╚═╝
+ *
+ *  hams.ai CLI — @hams-ai/cli
+ *
+ *  Commands:
+ *    hams              → interactive chat (default)
+ *    hams run "task"   → run single task and exit
+ *    hams tools        → list available tools
+ *    hams status       → check backend status
+ */
+
+const path = require("path");
+const fs = require("fs");
+const { program } = require("commander");
+const chalk = require("chalk");
+const ora = require("ora");
+const inquirer = require("inquirer");
+
+const { findPython, findRequirements, isPythonAgentInstalled, installPythonDeps } = require("../lib/installer");
+const { startServer, stopServer } = require("../lib/server");
+const HamsClient = require("../lib/client");
+
+// ─── Banner ──────────────────────────────────────────────────────────────────
+const BANNER = `
+${chalk.bold.white("hams.ai")} ${chalk.dim("— AI Coding Agent")}
+`;
+
+// ─── Resolve project root ─────────────────────────────────────────────────────
+function resolveProjectRoot() {
+  // 1. Environment variable
+  if (process.env.HAMS_PATH && fs.existsSync(process.env.HAMS_PATH)) {
+    return process.env.HAMS_PATH;
+  }
+  // 2. npm global install: .../node_modules/@hams-ai/cli/bin/hams.js → up 5 levels
+  const fromBin = path.resolve(__dirname, "..", "..", "..", "..", "..");
+  if (fs.existsSync(path.join(fromBin, "agent", "api.py"))) return fromBin;
+
+  // 3. Local dev: cli/ is sibling of agent/
+  const sibling = path.resolve(__dirname, "..", "..");
+  if (fs.existsSync(path.join(sibling, "agent", "api.py"))) return sibling;
+
+  // 4. Current working directory
+  if (fs.existsSync(path.join(process.cwd(), "agent", "api.py"))) return process.cwd();
+
+  return null;
+}
+
+// ─── Setup: find Python, install deps, start server ──────────────────────────
+async function setup(verbose = false, port = 8000) {
+  console.log(BANNER);
+  const spinner = ora({ text: "Starting hams.ai...", color: "white" }).start();
+
+  // 1. Find Python
+  const pythonCmd = findPython();
+  if (!pythonCmd) {
+    spinner.fail(
+      chalk.red("Python not found.\n") +
+      chalk.dim("  Install Python 3.8+ from https://python.org and add it to PATH.")
+    );
+    process.exit(1);
+  }
+
+  // 2. Find project root
+  const projectRoot = resolveProjectRoot();
+  if (!projectRoot) {
+    spinner.fail(
+      chalk.red("Cannot find hams.ai project folder.\n\n") +
+      chalk.white("  Set the HAMS_PATH environment variable:\n") +
+      chalk.dim("  PowerShell: ") + chalk.cyan(`$env:HAMS_PATH = "C:\\path\\to\\hams.ai"\n`) +
+      chalk.dim("  Linux/Mac:  ") + chalk.cyan(`export HAMS_PATH="/path/to/hams.ai"`)
+    );
+    process.exit(1);
+  }
+
+  spinner.text = "Checking Python dependencies...";
+
+  // 3. Auto-install deps if needed
+  if (!isPythonAgentInstalled(pythonCmd)) {
+    const reqFile = findRequirements(projectRoot);
+    if (reqFile) {
+      spinner.text = "Installing Python dependencies (first time setup)...";
+      try {
+        installPythonDeps(pythonCmd, reqFile);
+      } catch (err) {
+        spinner.warn(chalk.yellow(`Could not auto-install deps: ${err.message}`));
+        spinner.warn(chalk.dim(`Run manually: pip install -r ${reqFile}`));
+      }
+    }
+  }
+
+  // 4. Start Python backend
+  spinner.text = "Starting backend...";
+  try {
+    const { process: serverProc } = await startServer({ pythonCmd, projectRoot, port, verbose });
+    spinner.succeed(chalk.green(`hams.ai ready`) + chalk.dim(` — port ${port}`));
+    return { serverProc, port };
+  } catch (err) {
+    spinner.fail(chalk.red(`Backend failed to start: ${err.message}`));
+    if (!verbose) console.log(chalk.dim("  Tip: run with --verbose to see Python output"));
+    process.exit(1);
+  }
+}
+
+// ─── Print result ─────────────────────────────────────────────────────────────
+function printResult(text) {
+  process.stdout.write("\n");
+}
+
+// ─── Interactive REPL ─────────────────────────────────────────────────────────
+async function interactiveMode(client) {
+  console.log(chalk.dim('  Type your task and press Enter. Type "exit" to quit.\n'));
+
+  process.on("SIGINT", () => {
+    console.log(chalk.dim("\n\n  Goodbye.\n"));
+    process.exit(0);
+  });
+
+  while (true) {
+    const { task } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "task",
+        message: chalk.bold.white("›"),
+        validate: (v) => v.trim().length > 0 || "Please enter a task.",
+      },
+    ]);
+
+    const trimmed = task.trim();
+    if (["exit", "quit", "q"].includes(trimmed.toLowerCase())) {
+      console.log(chalk.dim("\n  Goodbye.\n"));
+      process.exit(0);
+    }
+
+    const spinner = ora({ text: chalk.dim("Thinking..."), color: "white" }).start();
+    try {
+      let output = "";
+      let started = false;
+      await client.streamTask(trimmed, (chunk) => {
+        if (!started) {
+          spinner.stop();
+          process.stdout.write("\n");
+          started = true;
+        }
+        process.stdout.write(chunk);
+        output += chunk;
+      });
+      if (!started) {
+        spinner.stop();
+        process.stdout.write("\n" + output);
+      }
+      process.stdout.write("\n\n");
+    } catch (err) {
+      spinner.fail(chalk.red(err.message));
+    }
+  }
+}
+
+// ─── Commands ─────────────────────────────────────────────────────────────────
+program
+  .name("hams")
+  .description("hams.ai — AI Coding Agent CLI")
+  .version("1.0.0", "-v, --version")
+  .option("--verbose", "Show Python backend output")
+  .option("--port <port>", "Backend port", "8000");
+
+// Default: interactive chat
+program
+  .command("chat", { isDefault: true })
+  .description("Start interactive chat (default)")
+  .action(async () => {
+    const opts = program.opts();
+    const port = parseInt(opts.port);
+    const { serverProc } = await setup(opts.verbose, port);
+    const client = new HamsClient(port);
+
+    process.on("exit", () => stopServer(serverProc));
+    process.on("SIGINT", () => { stopServer(serverProc); process.exit(0); });
+
+    await interactiveMode(client);
+  });
+
+// One-shot run
+program
+  .command("run <task>")
+  .description("Run a single task and exit")
+  .action(async (task) => {
+    const opts = program.opts();
+    const port = parseInt(opts.port);
+    const { serverProc } = await setup(opts.verbose, port);
+    const client = new HamsClient(port);
+
+    process.on("exit", () => stopServer(serverProc));
+
+    const spinner = ora({ text: chalk.dim("Running..."), color: "white" }).start();
+    try {
+      let started = false;
+      await client.streamTask(task, (chunk) => {
+        if (!started) { spinner.stop(); process.stdout.write("\n"); started = true; }
+        process.stdout.write(chunk);
+      });
+      process.stdout.write("\n\n");
+      stopServer(serverProc);
+      process.exit(0);
+    } catch (err) {
+      spinner.fail(chalk.red(err.message));
+      stopServer(serverProc);
+      process.exit(1);
+    }
+  });
+
+// List tools
+program
+  .command("tools")
+  .description("List available agent tools")
+  .action(async () => {
+    const opts = program.opts();
+    const port = parseInt(opts.port);
+    const { serverProc } = await setup(opts.verbose, port);
+    const client = new HamsClient(port);
+
+    try {
+      const tools = await client.tools();
+      console.log(chalk.bold("\n  Tools available in hams.ai:\n"));
+      if (Array.isArray(tools) && tools.length) {
+        tools.forEach((t) => {
+          const name = t.name || t;
+          const desc = t.description || "";
+          console.log(`  ${chalk.white("•")} ${chalk.bold(name)}  ${chalk.dim(desc)}`);
+        });
+      } else {
+        console.log(chalk.dim("  (no tools info returned by API)"));
+      }
+      console.log();
+    } catch (err) {
+      console.error(chalk.red(`Could not fetch tools: ${err.message}`));
+    }
+    stopServer(serverProc);
+    process.exit(0);
+  });
+
+// Status check (no server spawn — just check existing)
+program
+  .command("status")
+  .description("Check if backend is already running")
+  .action(async () => {
+    const opts = program.opts();
+    const port = parseInt(opts.port);
+    const client = new HamsClient(port);
+    try {
+      const h = await client.health();
+      console.log(chalk.green(`\n  hams.ai backend is running`) + chalk.dim(` on port ${port}`));
+      console.log(chalk.dim(`  ${JSON.stringify(h)}\n`));
+    } catch (_) {
+      console.log(chalk.dim(`\n  No backend found on port ${port}.\n`));
+    }
+    process.exit(0);
+  });
+
+program.parse(process.argv);

package/lib/client.js

@@ -0,0 +1,67 @@
+"use strict";
+
+const axios = require("axios");
+
+class HamsClient {
+  constructor(port = 8000) {
+    this.base = `http://127.0.0.1:${port}`;
+    this.http = axios.create({
+      baseURL: this.base,
+      timeout: 120_000,
+    });
+  }
+
+  async runTask(task) {
+    const resp = await this.http.post("/run", { task });
+    return resp.data;
+  }
+
+  async streamTask(task, onChunk) {
+    try {
+      const resp = await this.http.post(
+        "/run/stream",
+        { task },
+        { responseType: "stream" }
+      );
+      return new Promise((resolve, reject) => {
+        let buffer = "";
+        resp.data.on("data", (chunk) => {
+          buffer += chunk.toString();
+          const lines = buffer.split("\n");
+          buffer = lines.pop();
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              try {
+                const payload = JSON.parse(line.slice(6));
+                onChunk(payload.text || payload.content || "");
+              } catch (_) {
+                onChunk(line.slice(6));
+              }
+            }
+          }
+        });
+        resp.data.on("end", resolve);
+        resp.data.on("error", reject);
+      });
+    } catch (err) {
+      const result = await this.runTask(task);
+      onChunk(result.result || result.output || JSON.stringify(result));
+    }
+  }
+
+  async health() {
+    const resp = await this.http.get("/health");
+    return resp.data;
+  }
+
+  async tools() {
+    try {
+      const resp = await this.http.get("/tools");
+      return resp.data;
+    } catch (_) {
+      return [];
+    }
+  }
+}
+
+module.exports = HamsClient;

package/lib/installer.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const { spawnSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const which = require("which");
+
+function findPython() {
+  for (const cmd of ["python3", "python"]) {
+    try {
+      which.sync(cmd);
+      const result = spawnSync(cmd, ["--version"], { encoding: "utf8" });
+      if (result.status === 0) return cmd;
+    } catch (_) {}
+  }
+  return null;
+}
+
+function findRequirements(projectRoot) {
+  const candidates = [
+    path.join(projectRoot, "requirements.txt"),
+    path.join(projectRoot, "..", "requirements.txt"),
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+function isPythonAgentInstalled(pythonCmd) {
+  const result = spawnSync(
+    pythonCmd,
+    ["-c", "import agent; print('ok')"],
+    { encoding: "utf8" }
+  );
+  return result.status === 0;
+}
+
+function installPythonDeps(pythonCmd, requirementsPath) {
+  const result = spawnSync(
+    pythonCmd,
+    ["-m", "pip", "install", "-r", requirementsPath, "--quiet"],
+    { encoding: "utf8", stdio: "pipe" }
+  );
+  if (result.status !== 0) {
+    throw new Error(`pip install failed:\n${result.stderr || result.stdout}`);
+  }
+  return true;
+}
+
+module.exports = { findPython, findRequirements, isPythonAgentInstalled, installPythonDeps };

package/lib/server.js

@@ -0,0 +1,72 @@
+"use strict";
+
+const { spawn } = require("child_process");
+const path = require("path");
+const http = require("http");
+const fs = require("fs");
+
+const DEFAULT_PORT = 8000;
+const STARTUP_TIMEOUT_MS = 30_000;
+
+function waitForServer(port, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const deadline = Date.now() + timeoutMs;
+
+    function poll() {
+      if (Date.now() > deadline) {
+        return reject(new Error(`hams.ai backend did not start within ${timeoutMs / 1000}s`));
+      }
+      const req = http.get(`http://127.0.0.1:${port}/health`, (res) => {
+        if (res.statusCode < 500) resolve();
+        else setTimeout(poll, 500);
+      });
+      req.on("error", () => setTimeout(poll, 500));
+      req.setTimeout(1000, () => { req.destroy(); setTimeout(poll, 500); });
+    }
+
+    poll();
+  });
+}
+
+async function startServer({ pythonCmd, projectRoot, port = DEFAULT_PORT, verbose = false }) {
+  const apiEntry = path.join(projectRoot, "agent", "api.py");
+  const mainEntry = path.join(projectRoot, "agent", "main.py");
+  const entry = fs.existsSync(apiEntry) ? apiEntry : mainEntry;
+
+  const env = {
+    ...process.env,
+    AGENT_PORT: String(port),
+    PYTHONPATH: projectRoot,
+  };
+
+  const child = spawn(pythonCmd, [entry, "--port", String(port)], {
+    cwd: projectRoot,
+    env,
+    stdio: verbose ? "inherit" : "pipe",
+  });
+
+  if (!verbose) {
+    let stderr = "";
+    child.stderr && child.stderr.on("data", (d) => { stderr += d.toString(); });
+    child.on("exit", (code) => {
+      if (code !== 0 && code !== null) {
+        stderr && process.stderr.write(`\n[hams.ai] ${stderr}\n`);
+      }
+    });
+  }
+
+  child.on("error", (err) => {
+    throw new Error(`Failed to start hams.ai backend: ${err.message}`);
+  });
+
+  await waitForServer(port, STARTUP_TIMEOUT_MS);
+  return { process: child, port };
+}
+
+function stopServer(child) {
+  if (!child || child.killed) return;
+  child.kill("SIGTERM");
+  setTimeout(() => { if (!child.killed) child.kill("SIGKILL"); }, 5000);
+}
+
+module.exports = { startServer, stopServer };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@hams-ai/cli",
+  "version": "1.0.0",
+  "description": "hams.ai — Official CLI for the hams.ai coding agent",
+  "bin": {
+    "hams": "./bin/hams.js"
+  },
+  "main": "./bin/hams.js",
+  "scripts": {
+    "start": "node bin/hams.js"
+  },
+  "keywords": ["hams", "hams-ai", "ai", "agent", "cli", "coding"],
+  "author": "hams.ai",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "inquirer": "^8.2.6",
+    "ora": "^5.4.1",
+    "which": "^3.0.1"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}