playnex-cli 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# Playnex CLI
+
+Local-first CLI for managing Playnex agents, capsules, and tools.
+
+## Install dependencies
+
+npm install
+
+## Link globally (for development)
+
+npm link
+
+## Commands
+
+playnex login

package/bin/playnex.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import chalk from "chalk";
+import login from "../src/commands/login.js";
+
+// -----------------------------------------------------
+// Custom Help Banner
+// -----------------------------------------------------
+program.configureHelp({
+  sortSubcommands: false,
+  sortOptions: false,
+  formatHelp: (cmd, helper) => {
+    const b = chalk.bold;
+    const g = chalk.gray;
+
+    return `
+${b("Playnex CLI — Local‑First AI Agents")}
+${g("────────────────────────────────────────────")}
+
+Playnex is a local‑first automation platform.  
+Agents run on your machine, use local tools, and sync with your Playnex workspace.
+
+${b("Quick Start")}
+  playnex login
+  playnex agent create
+  playnex agent chat myagent
+
+${b("Core Concepts")}
+  Agents     Autonomous workers you define (model, purpose, tools)
+  Workspace  Your synced project files and context
+  Capsules   Versioned knowledge bundles mirrored locally
+  Scheduler  Background automation for agents
+  Tools      Capabilities you attach to agents
+
+${b("Agent Commands")}
+  agent create              Create a new agent
+  agent chat <name>         Chat with an agent
+  agent run <name>          Run an agent in automation mode
+  agent add-tool <n> <t>    Attach a tool to an agent
+
+${b("Workspace")}
+  workspace sync            Pull workspace from cloud
+
+${b("Capsules")}
+  capsules mirror           Mirror all capsules locally
+
+${b("Scheduler")}
+  scheduler add <a> <int>   Schedule an agent (e.g. 1h, 30m)
+  scheduler list            List scheduled agents
+  scheduler remove <id>     Remove a scheduled agent
+  scheduler run             Run scheduler daemon
+
+${b("Tools")}
+  tools register <tool>     Register a tool
+  tools list                List tools
+  tools info <tool>         Show tool details
+
+${b("Examples")}
+  playnex agent create
+  playnex agent chat writer
+  playnex scheduler add reporter 1h
+  playnex tools register websearch
+
+${b("Options")}
+  -h, --help                Show help
+  -V, --version             Show version
+
+${g("Tip: Run 'playnex <command> --help' for detailed usage.")}
+`;
+  }
+});
+
+
+// -----------------------------------------------------
+// Base CLI metadata
+// -----------------------------------------------------
+program
+  .name("playnex")
+  .description("Playnex CLI — local-first AI agents")
+  .version("0.1.0");
+
+// -----------------------------------------------------
+// Authentication
+// -----------------------------------------------------
+program
+  .command("login")
+  .description("Log in to your Playnex account")
+  .action(login);
+
+// -----------------------------------------------------
+// Agent Commands
+// -----------------------------------------------------
+const agent = program.command("agent").description("Manage Playnex agents");
+
+agent
+  .command("create")
+  .description("Create a new Playnex agent")
+  .action(() =>
+    import("../src/commands/agent/create.js").then((m) => m.default())
+  );
+
+agent
+  .command("chat <name>")
+  .description("Chat with a Playnex agent")
+  .action((name) =>
+    import("../src/commands/agent/chat.js").then((m) => m.default(name))
+  );
+
+agent
+  .command("run <name>")
+  .description("Run a Playnex agent in automation mode")
+  .action((name) =>
+    import("../src/commands/agent/run.js").then((m) => m.default(name))
+  );
+
+agent
+  .command("add-tool <name> <tool>")
+  .description("Add a tool to a Playnex agent")
+  .action((name, tool) =>
+    import("../src/commands/agent/add-tool.js").then((m) =>
+      m.default(name, tool)
+    )
+  );
+
+// -----------------------------------------------------
+// Workspace Commands
+// -----------------------------------------------------
+const workspace = program
+  .command("workspace")
+  .description("Workspace operations");
+
+workspace
+  .command("sync")
+  .description("Sync Playnex workspace from cloud to local")
+  .action(() =>
+    import("../src/commands/workspace/sync.js").then((m) => m.default())
+  );
+
+// -----------------------------------------------------
+// Capsule Commands
+// -----------------------------------------------------
+const capsules = program
+  .command("capsules")
+  .description("Capsule operations");
+
+capsules
+  .command("mirror")
+  .description("Mirror all capsules locally for offline use")
+  .action(() =>
+    import("../src/commands/capsules/mirror.js").then((m) => m.default())
+  );
+
+// -----------------------------------------------------
+// Scheduler Commands
+// -----------------------------------------------------
+const scheduler = program
+  .command("scheduler")
+  .description("Agent scheduler");
+
+scheduler
+  .command("add <agent> <interval>")
+  .description("Schedule an agent to run automatically")
+  .action((agentName, interval) =>
+    import("../src/commands/scheduler/scheduler.js").then((m) =>
+      m.schedulerAdd(agentName, interval)
+    )
+  );
+
+scheduler
+  .command("list")
+  .description("List scheduled agents")
+  .action(() =>
+    import("../src/commands/scheduler/scheduler.js").then((m) =>
+      m.schedulerList()
+    )
+  );
+
+scheduler
+  .command("remove <id>")
+  .description("Remove a scheduled agent")
+  .action((id) =>
+    import("../src/commands/scheduler/scheduler.js").then((m) =>
+      m.schedulerRemove(id)
+    )
+  );
+
+scheduler
+  .command("run")
+  .description("Run the scheduler daemon")
+  .action(() =>
+    import("../src/commands/scheduler/scheduler.js").then((m) =>
+      m.schedulerRun()
+    )
+  );
+
+// -----------------------------------------------------
+// Tool Registry Commands
+// -----------------------------------------------------
+const tools = program.command("tools").description("Tool registry operations");
+
+tools
+  .command("register <tool>")
+  .description("Register a tool in the tool registry")
+  .action((tool) =>
+    import("../src/commands/tools/registry.js").then((m) =>
+      m.registerTool(tool)
+    )
+  );
+
+tools
+  .command("list")
+  .description("List all registered tools")
+  .action(() =>
+    import("../src/commands/tools/registry.js").then((m) => m.listTools())
+  );
+
+tools
+  .command("info <tool>")
+  .description("Show detailed info for a tool")
+  .action((tool) =>
+    import("../src/commands/tools/registry.js").then((m) =>
+      m.toolInfo(tool)
+    )
+  );
+
+// -----------------------------------------------------
+// Parse CLI
+// -----------------------------------------------------
+program.parse();

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "playnex-cli",
+  "version": "0.1.0",
+  "description": "Playnex CLI — local-first AI agents, capsules, and tools.",
+  "bin": {
+    "playnex": "./bin/playnex.js"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "inquirer": "^13.2.5",
+    "ollama": "^0.6.3"
+  },
+  "license": "MIT"
+}

package/playnex-bootstrap.ps1

@@ -0,0 +1,30 @@
+$ErrorActionPreference = 'Stop'
+
+function Ensure-Dir($path) {
+  if (-not (Test-Path $path)) {
+    New-Item -ItemType Directory -Path $path | Out-Null
+  }
+}
+
+Write-Host 'Creating agent system...'
+
+$root = Get-Location
+$src = Join-Path $root 'src'
+$services = Join-Path $src 'services'
+$commands = Join-Path $src 'commands'
+$agentCmd = Join-Path $commands 'agent'
+
+Ensure-Dir $src
+Ensure-Dir $services
+Ensure-Dir $commands
+Ensure-Dir $agentCmd
+
+$agentsJs = @'
+import fs from "fs";
+export const test = true;
+'@
+
+Set-Content -Path (Join-Path $services 'agents.js') -Value $agentsJs -Encoding UTF8
+
+Write-Host 'Done.'
+Write-Host 'Run: npm install commander chalk inquirer ollama'

package/src/commands/agent/add-tool.js

@@ -0,0 +1,40 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+
+const AGENTS_DIR = path.join(os.homedir(), ".playnex", "workspace", "agents");
+const TOOLS_DIR = path.join(process.cwd(), "src", "tools");
+
+function loadAgent(name) {
+  const file = path.join(AGENTS_DIR, `${name}.json`);
+  if (!fs.existsSync(file)) {
+    console.log(chalk.red(`Agent '${name}' not found.`));
+    process.exit(1);
+  }
+  return { file, data: JSON.parse(fs.readFileSync(file, "utf8")) };
+}
+
+export default async function addTool(name, toolName) {
+  const { file, data } = loadAgent(name);
+
+  console.log(chalk.cyan(`\nAdd a tool to agent: ${name}\n`));
+
+  const availableTools = fs
+    .readdirSync(TOOLS_DIR)
+    .filter((f) => f.endsWith(".js"))
+    .map((f) => f.replace(".js", ""));
+
+  if (!availableTools.includes(toolName)) {
+    console.log(chalk.red(`Tool '${toolName}' does not exist.`));
+    process.exit(1);
+  }
+
+  if (!data.tools.includes(toolName)) {
+    data.tools.push(toolName);
+  }
+
+  fs.writeFileSync(file, JSON.stringify(data, null, 2), "utf8");
+
+  console.log(chalk.green(`\n✔ Tool '${toolName}' added to agent '${name}'.\n`));
+}

package/src/commands/agent/chat.js

@@ -0,0 +1,90 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+import readline from "readline";
+import ollama from "ollama";
+
+const AGENTS_DIR = path.join(os.homedir(), ".playnex", "workspace", "agents");
+
+function loadAgent(name) {
+  const file = path.join(AGENTS_DIR, `${name}.json`);
+  if (!fs.existsSync(file)) {
+    console.log(chalk.red(`Agent '${name}' not found.`));
+    process.exit(1);
+  }
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function askUser(promptText) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) =>
+    rl.question(promptText, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    })
+  );
+}
+
+export default async function agentChat(name) {
+  const agent = loadAgent(name);
+
+  // ⭐ NEW: Validate model before doing anything else
+  if (!agent.model || typeof agent.model !== "string") {
+    console.log(chalk.red(`\nAgent '${name}' has no model assigned.`));
+    console.log(chalk.yellow("Edit the agent JSON and set a model, e.g.:"));
+    console.log(chalk.gray(`  "model": "llama3"`));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan(`\nChatting with agent: ${name}`));
+  console.log(chalk.gray(`Model: ${agent.model}`));
+  console.log(chalk.gray(`Purpose: ${agent.purpose}\n`));
+
+  let messages = [
+    {
+      role: "system",
+      content: agent.purpose,
+    },
+  ];
+
+  while (true) {
+    const userInput = await askUser(chalk.green("You: "));
+
+    if (!userInput) continue;
+    if (userInput.toLowerCase() === "exit") {
+      console.log(chalk.yellow("\nExiting chat.\n"));
+      process.exit(0);
+    }
+
+    messages.push({ role: "user", content: userInput });
+
+    console.log(chalk.cyan("\nAgent: "));
+
+    let responseText = "";
+
+    // ⭐ This now always has a valid model
+    const stream = await ollama.chat({
+      model: agent.model,
+      messages,
+      stream: true,
+    });
+
+    for await (const chunk of stream) {
+      const token = chunk.message?.content || "";
+      responseText += token;
+      process.stdout.write(token);
+    }
+
+    console.log("\n");
+
+    messages.push({
+      role: "assistant",
+      content: responseText,
+    });
+  }
+}

package/src/commands/agent/create.js

@@ -0,0 +1,62 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+import readline from "readline";
+import { loadConfig } from "../../services/config.js";
+
+const AGENTS_DIR = path.join(os.homedir(), ".playnex", "workspace", "agents");
+
+function ask(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) =>
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    })
+  );
+}
+
+export default async function agentCreate() {
+  console.log(chalk.cyan("\nCreate a New Playnex Agent\n"));
+
+  const config = loadConfig();
+  if (!config.token) {
+    console.log(chalk.red("You must log in first."));
+    console.log("Run: playnex login");
+    process.exit(1);
+  }
+
+  const name = await ask("Agent name: ");
+  const purpose = await ask("Purpose (one sentence): ");
+
+  let model = "";
+  while (!model) {
+    model = await ask("Model (e.g., llama3): ");
+    if (!model) {
+      console.log(chalk.yellow("Model is required. Please enter a model name.\n"));
+    }
+  }
+
+  const agent = {
+    name,
+    purpose,
+    model,
+    tools: [],
+    createdAt: new Date().toISOString(),
+  };
+
+  if (!fs.existsSync(AGENTS_DIR)) {
+    fs.mkdirSync(AGENTS_DIR, { recursive: true });
+  }
+
+  const filePath = path.join(AGENTS_DIR, `${name}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(agent, null, 2), "utf8");
+
+  console.log(chalk.green(`\n✔ Agent '${name}' created successfully.`));
+  console.log(chalk.gray(`Saved to: ${filePath}\n`));
+}

package/src/commands/agent/run.js

@@ -0,0 +1,102 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+import ollama from "ollama";
+
+const AGENTS_DIR = path.join(os.homedir(), ".playnex", "workspace", "agents");
+const TOOLS_DIR = path.join(process.cwd(), "src", "tools");
+
+function loadAgent(name) {
+  const file = path.join(AGENTS_DIR, `${name}.json`);
+  if (!fs.existsSync(file)) {
+    console.log(chalk.red(`Agent '${name}' not found.`));
+    process.exit(1);
+  }
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+async function loadTool(toolName) {
+  const toolPath = path.join(TOOLS_DIR, `${toolName}.js`);
+  if (!fs.existsSync(toolPath)) {
+    console.log(chalk.red(`Tool '${toolName}' not found in src/tools.`));
+    process.exit(1);
+  }
+  const module = await import(toolPath);
+  return module.default;
+}
+
+export default async function agentRun(name) {
+  const agent = loadAgent(name);
+
+  console.log(chalk.cyan(`\nRunning agent: ${name}`));
+  console.log(chalk.gray(`Model: ${agent.model}`));
+  console.log(chalk.gray(`Tools: ${agent.tools.join(", ")}`));
+  console.log(chalk.gray(`Purpose: ${agent.purpose}\n`));
+
+  const systemPrompt = `
+You are the agent: ${name}
+Purpose: ${agent.purpose}
+
+You are running in automation mode.
+Think step-by-step.
+If you want to use a tool, output JSON ONLY in this format:
+
+{
+  "tool": "tool-name",
+  "input": "text to send to the tool"
+}
+
+Otherwise, output your final result as plain text.
+`;
+
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: "Begin your autonomous reasoning cycle." },
+  ];
+
+  console.log(chalk.cyan("Agent output:\n"));
+
+  let responseText = "";
+
+  const stream = await ollama.chat({
+    model: agent.model,
+    messages,
+    stream: true,
+  });
+
+  for await (const chunk of stream) {
+    const token = chunk.message?.content || "";
+    responseText += token;
+    process.stdout.write(token);
+  }
+
+  console.log("\n");
+
+  // Try to detect tool JSON
+  let toolCall = null;
+  try {
+    const start = responseText.indexOf("{");
+    const end = responseText.lastIndexOf("}");
+    if (start !== -1 && end !== -1) {
+      const json = responseText.slice(start, end + 1);
+      toolCall = JSON.parse(json);
+    }
+  } catch {}
+
+  if (toolCall && toolCall.tool) {
+    console.log(chalk.yellow(`\n🔧 Agent requested tool: ${toolCall.tool}`));
+
+    if (!agent.tools.includes(toolCall.tool)) {
+      console.log(chalk.red(`Agent does not have access to tool '${toolCall.tool}'.`));
+      process.exit(1);
+    }
+
+    const toolFn = await loadTool(toolCall.tool);
+    await toolFn(agent, toolCall.input);
+
+    console.log(chalk.green("\n✔ Tool execution complete.\n"));
+  } else {
+    console.log(chalk.green("\n✔ Automation cycle complete.\n"));
+  }
+}

package/src/commands/capsules/mirror.js

@@ -0,0 +1,58 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+import axios from "axios";
+import { loadConfig } from "../../services/config.js";
+
+/**
+ * capsules mirror
+ * Creates a full local mirror of all capsules for offline use.
+ */
+
+const API_BASE = "https://playnex.app";
+
+export default async function capsuleMirror() {
+  const config = loadConfig();
+
+  if (!config.token) {
+    console.log(chalk.red("You must log in first."));
+    console.log("Run: playnex login");
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan("\nMirroring capsules to local workspace..."));
+
+  const WORKSPACE_DIR = path.join(os.homedir(), ".playnex", "workspace");
+  const CAPSULES_DIR = path.join(WORKSPACE_DIR, "capsules-local");
+
+  // Ensure directory exists
+  if (!fs.existsSync(CAPSULES_DIR)) {
+    fs.mkdirSync(CAPSULES_DIR, { recursive: true });
+  }
+
+  console.log(chalk.gray("Fetching capsules from cloud..."));
+
+  const res = await axios.get(
+    `${API_BASE}/capsules/all`,
+    {
+      headers: { Authorization: `Bearer ${config.token}` }
+    }
+  );
+
+  const capsules = res.data || [];
+
+  if (!Array.isArray(capsules) || capsules.length === 0) {
+    console.log(chalk.yellow("No capsules found."));
+    return;
+  }
+
+  // Write each capsule locally
+  capsules.forEach(capsule => {
+    const file = path.join(CAPSULES_DIR, `${capsule.id}.json`);
+    fs.writeFileSync(file, JSON.stringify(capsule, null, 2), "utf8");
+  });
+
+  console.log(chalk.green(`✔ Mirrored ${capsules.length} capsules locally.`));
+  console.log(chalk.green(`Local capsule directory: ${CAPSULES_DIR}\n`));
+}