@lazyingart/agintiflow 0.6.0 → 0.7.0

package/README.md

@@ -46,6 +46,16 @@ aginti --list-profiles
 aginti --sandbox-status --sandbox-mode docker-readonly
 ```
 
+Start an interactive Codex-style CLI chat from any project folder:
+
+```bash
+aginti
+# or explicitly:
+aginti chat
+```
+
+Inside chat, type normal requests such as `write a small Python CLI app with tests`. Use `/help` for commands, `/docker on` to switch to Docker workspace mode with approved package installs, `/sessions` to list project runs, and `/resume <session-id>` to continue work.
+
 Launch the local web UI from an installed package:
 
 ```bash
@@ -71,8 +81,8 @@ aginti doctor --capabilities
 aginti sessions list
 aginti sessions show <session-id>
 aginti resume <session-id> "continue with a short follow-up"
-aginti --profile code --provider mock --routing manual "Create notes/hello.md"
-aginti --allow-shell --sandbox-mode docker-workspace --approve-package-installs "set up and test this project"
+aginti --profile code "write a small Python CLI app with tests"
+aginti --sandbox-mode docker-workspace --approve-package-installs "set up this project and run the tests"
 ```
 
 Run from a source checkout:
@@ -324,7 +334,7 @@ Package policy values:
 | `prompt` | Return a clear approval-required error; the UI can switch to approved. |
 | `allow` | Permit package/setup commands. Docker workspace mode also allows broader shell/network commands while keeping secrets and npm publishing blocked. |
 
-Toolchain commands such as `python3 plot.py`, `latexmk -pdf paper.tex`, and `pdflatex -interaction=nonstopmode -halt-on-error paper.tex` are allowlisted only when the shell tool is enabled. In Docker mode they require `docker-workspace` because they write outputs back to `/workspace`. File and canvas tools accept both normal relative paths and Docker virtual paths like `/workspace/report.pdf`, while other absolute host paths remain blocked.
+Toolchain commands such as `python3 plot.py`, `latexmk -pdf paper.tex`, and `pdflatex -interaction=nonstopmode -halt-on-error paper.tex` are allowlisted only when the shell tool is enabled. In Docker mode the project folder is mounted as `/workspace`; any file written to `/workspace/report.pdf` appears on the host as `<your-project>/report.pdf`. CLI runs print both the host workspace and the Docker mapping before execution. File and canvas tools accept both normal relative paths and Docker virtual paths like `/workspace/report.pdf`, while other absolute host paths remain blocked.
 
 Safe preflight endpoints:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "AgInTiFlow is a resumable Playwright website-control agent with OpenAI-compatible tool calling.",
   "license": "Apache-2.0",
@@ -41,6 +41,7 @@
     "scripts/install-docker-ubuntu.sh",
     "scripts/setup-agent-toolchain-docker.sh",
     "scripts/real-deepseek-capabilities.js",
+    "scripts/smoke-cli-chat.js",
     "scripts/smoke-coding-tools.js",
     "scripts/smoke-capabilities.js",
     "scripts/smoke-toolchain-docker.js",
@@ -59,10 +60,11 @@
     "check": "node --check run.js && node --check web.js && node --check bin/aginti-cli.js && node --check src/*.js",
     "setup:toolchain-docker": "scripts/setup-agent-toolchain-docker.sh",
     "smoke:coding-tools": "node scripts/smoke-coding-tools.js",
+    "smoke:cli-chat": "node scripts/smoke-cli-chat.js",
     "smoke:toolchain-docker": "node scripts/smoke-toolchain-docker.js",
     "smoke:web-api": "node scripts/smoke-web-api.js",
     "real:deepseek": "node scripts/real-deepseek-capabilities.js",
-    "test": "npm run check && npm run smoke:web-api && npm run smoke:coding-tools && npm run smoke:capabilities",
+    "test": "npm run check && npm run smoke:web-api && npm run smoke:coding-tools && npm run smoke:capabilities && npm run smoke:cli-chat",
     "pack:dry-run": "npm pack --dry-run",
     "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },

package/scripts/smoke-cli-chat.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-cli-chat-"));
+const binPath = path.join(repoRoot, "bin/aginti-cli.js");
+
+function runChat(inputText) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      process.execPath,
+      [binPath, "chat", "--provider", "mock", "--routing", "manual", "--profile", "code"],
+      {
+        cwd: tempRoot,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          AGINTIFLOW_RUNTIME_DIR: "",
+        },
+      }
+    );
+
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error("interactive chat smoke timed out"));
+    }, 25000);
+
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve({ stdout, stderr });
+      else reject(new Error(`interactive chat exited ${code}\n${stdout}\n${stderr}`));
+    });
+
+    child.stdin.end(inputText);
+  });
+}
+
+try {
+  const result = await runChat("Create notes/interactive.md with a short CLI chat smoke message\n/exit\n");
+  const written = await fs.readFile(path.join(tempRoot, "notes/interactive.md"), "utf8");
+  if (!written.includes("Created by AgInTiFlow mock mode.")) {
+    throw new Error("interactive chat did not create the expected file");
+  }
+  if (!result.stdout.includes("Interactive agent chat")) {
+    throw new Error("interactive chat did not print its banner");
+  }
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        projectRoot: tempRoot,
+        checks: ["interactive-chat", "mock-file-write"],
+      },
+      null,
+      2
+    )
+  );
+} finally {
+  await fs.rm(tempRoot, { recursive: true, force: true });
+}

package/src/agent-runner.js

@@ -791,6 +791,16 @@ export async function runAgent(config) {
     console.log(`Provider: ${config.provider}`);
     console.log(`Model: ${config.model}`);
     console.log(`Routing: ${config.routingMode} (${config.routeReason})`);
+    console.log(`Workspace: ${config.commandCwd}`);
+    console.log(`Sessions: ${config.sessionsDir}`);
+    if (config.useDockerSandbox) {
+      console.log(
+        `Docker: image=${config.dockerSandboxImage} mode=${config.sandboxMode} packagePolicy=${config.packageInstallPolicy}`
+      );
+      console.log(`Docker workspace: /workspace -> ${config.commandCwd}`);
+    } else if (config.allowShellTool) {
+      console.log(`Shell: host policy=${config.packageInstallPolicy}`);
+    }
     if (state.plan) {
       console.log("\nPlan:");
       console.log(state.plan);

package/src/cli.js

@@ -4,6 +4,7 @@ import { listAgentWrappers } from "./tool-wrappers.js";
 import { getModelPresets } from "./model-routing.js";
 import { getDockerSandboxStatus, runDockerPreflight } from "./docker-sandbox.js";
 import { buildCapabilityReport, printCapabilityReport } from "./capabilities.js";
+import { startInteractiveCli } from "./interactive-cli.js";
 import {
   doctorReport,
   initProject,
@@ -52,6 +53,7 @@ export function parseArgs(argv) {
     sandboxStatus: false,
     sandboxPreflight: false,
     web: false,
+    interactive: false,
     port: "",
     host: "",
     listProfiles: false,
@@ -64,6 +66,10 @@ export function parseArgs(argv) {
       result.web = true;
       continue;
     }
+    if (arg === "chat" || arg === "interactive" || arg === "--chat" || arg === "--interactive") {
+      result.interactive = true;
+      continue;
+    }
     if (arg === "--port") {
       result.port = readOption(argv, i);
       i += 1;
@@ -133,6 +139,10 @@ export function parseArgs(argv) {
       result.allowShellTool = true;
       continue;
     }
+    if (arg === "--no-shell") {
+      result.allowShellTool = false;
+      continue;
+    }
     if (arg === "--allow-destructive" || arg === "--trusted-host-shell") {
       result.allowDestructive = true;
       continue;
@@ -197,6 +207,12 @@ export function parseArgs(argv) {
   return result;
 }
 
+function printUsage() {
+  console.log(
+    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti [--routing smart|fast|complex|manual] [--provider deepseek|openai|mock] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-destructive] [--allow-file-tools|--no-file-tools] [--allow-wrappers --wrapper codex] [--sandbox-status|--sandbox-preflight] "your task"'
+  );
+}
+
 function printRoutes() {
   const presets = getModelPresets();
   for (const preset of Object.values(presets)) {
@@ -312,6 +328,11 @@ async function handleSessionsCommand(argv) {
 }
 
 export async function main(argv = process.argv.slice(2)) {
+  if (argv[0] === "--help" || argv[0] === "help" || argv[0] === "-h") {
+    printUsage();
+    return;
+  }
+
   if (argv[0] === "--version" || argv[0] === "version" || argv[0] === "-v") {
     console.log(packageJson.version);
     return;
@@ -393,13 +414,21 @@ export async function main(argv = process.argv.slice(2)) {
       console.error('Usage: aginti resume <session-id> "new prompt"');
       process.exit(1);
     }
-    const config = loadConfig({ ...parseArgs([prompt]), resume: sessionId, goal: prompt }, { packageDir });
+    const config = loadConfig(
+      { ...parseArgs([prompt]), resume: sessionId, goal: prompt, allowShellTool: true, allowFileTools: true },
+      { packageDir }
+    );
     await runAgent(config);
     return;
   }
 
   const args = parseArgs(argv);
 
+  if (args.interactive || (!args.goal && !args.resume && process.stdin.isTTY)) {
+    await startInteractiveCli(args, { packageDir, packageVersion: packageJson.version });
+    return;
+  }
+
   if (args.web) {
     if (args.port) process.env.PORT = String(args.port);
     if (args.host) process.env.HOST = String(args.host);
@@ -433,12 +462,17 @@ export async function main(argv = process.argv.slice(2)) {
   }
 
   if (!args.goal && !args.resume) {
-    console.error(
-      'Usage: aginti-cli web [--port 3210] OR aginti-cli [--routing smart|fast|complex|manual] [--provider deepseek|openai|mock] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell] [--allow-destructive] [--allow-file-tools|--no-file-tools] [--allow-wrappers --wrapper codex] [--sandbox-status|--sandbox-preflight] "your task"'
-    );
+    printUsage();
     process.exit(1);
   }
 
-  const config = loadConfig(args, { packageDir });
+  const config = loadConfig(
+    {
+      ...args,
+      allowShellTool: args.allowShellTool ?? true,
+      allowFileTools: args.allowFileTools ?? true,
+    },
+    { packageDir }
+  );
   await runAgent(config);
 }

package/src/interactive-cli.js

@@ -0,0 +1,225 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { runAgent } from "./agent-runner.js";
+import { loadConfig } from "./config.js";
+import { initProject, listProjectSessions } from "./project.js";
+import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./command-policy.js";
+import { normalizeTaskProfile } from "./task-profiles.js";
+
+function printHelp() {
+  console.log(
+    [
+      "Commands:",
+      "  /help                     Show this help.",
+      "  /status                   Show active route, workspace, sandbox, and session.",
+      "  /new                      Start a fresh session on the next message.",
+      "  /resume <session-id>      Continue a saved session.",
+      "  /sessions                 List recent sessions in this project.",
+      "  /profile <name>           Set task profile, e.g. code, website, latex, maintenance.",
+      "  /routing <mode>           Set routing: smart, fast, complex, manual.",
+      "  /provider <name>          Set provider: deepseek, openai, mock.",
+      "  /model <name>             Set an explicit model, or /model auto.",
+      "  /docker on                Use docker-workspace with approved package installs.",
+      "  /docker off               Use host shell policy.",
+      "  /installs block|prompt|allow",
+      "  /cwd <path>               Change command workspace.",
+      "  /exit                     Quit.",
+      "",
+      "Type a normal request to run the agent. Example: write a Python CLI app with tests",
+    ].join("\n")
+  );
+}
+
+function printStatus(state) {
+  console.log(`project=${process.cwd()}`);
+  console.log(`cwd=${state.commandCwd || process.cwd()}`);
+  console.log(`session=${state.sessionId || "new"}`);
+  console.log(`provider=${state.provider || "auto"} routing=${state.routingMode} model=${state.model || "auto"}`);
+  console.log(`profile=${state.taskProfile} maxSteps=${state.maxSteps}`);
+  console.log(
+    `shell=${state.allowShellTool} files=${state.allowFileTools} sandbox=${state.sandboxMode} installs=${state.packageInstallPolicy}`
+  );
+  if (state.sandboxMode !== "host") {
+    console.log(`dockerWorkspace=/workspace -> ${state.commandCwd || process.cwd()}`);
+  }
+}
+
+function createState(args = {}) {
+  return {
+    provider: args.provider || "",
+    model: args.model || "",
+    routingMode: args.routingMode || "smart",
+    commandCwd: args.commandCwd || process.cwd(),
+    sandboxMode: normalizeSandboxMode(args.sandboxMode || "host"),
+    packageInstallPolicy: normalizePackageInstallPolicy(args.packageInstallPolicy || "prompt"),
+    allowShellTool: args.allowShellTool ?? true,
+    allowFileTools: args.allowFileTools ?? true,
+    allowWrapperTools: args.allowWrapperTools ?? false,
+    allowDestructive: args.allowDestructive ?? false,
+    preferredWrapper: args.preferredWrapper || "codex",
+    taskProfile: normalizeTaskProfile(args.taskProfile || "auto"),
+    headless: args.headless ?? false,
+    maxSteps: Number.isFinite(args.maxSteps) && args.maxSteps > 0 ? args.maxSteps : 15,
+    sessionId: args.resume || "",
+  };
+}
+
+async function handleCommand(line, state, packageDir) {
+  const [command, ...rest] = line.slice(1).trim().split(/\s+/);
+  const value = rest.join(" ").trim();
+
+  if (!command || command === "help" || command === "?") {
+    printHelp();
+    return true;
+  }
+  if (command === "exit" || command === "quit" || command === "q") return false;
+  if (command === "status") {
+    printStatus(state);
+    return true;
+  }
+  if (command === "new") {
+    state.sessionId = "";
+    console.log("Next message will start a new session.");
+    return true;
+  }
+  if (command === "resume") {
+    if (!value) console.log("Usage: /resume <session-id>");
+    else {
+      state.sessionId = value;
+      console.log(`Resuming ${state.sessionId}`);
+    }
+    return true;
+  }
+  if (command === "sessions") {
+    const sessions = await listProjectSessions(process.cwd(), 20);
+    if (sessions.length === 0) console.log("No project-local sessions found.");
+    else {
+      for (const session of sessions) {
+        const goal = session.goal ? ` ${session.goal.slice(0, 80)}` : "";
+        console.log(`${session.sessionId} ${session.provider}/${session.model} ${session.updatedAt}${goal}`);
+      }
+    }
+    return true;
+  }
+  if (command === "profile") {
+    state.taskProfile = normalizeTaskProfile(value || "auto");
+    console.log(`profile=${state.taskProfile}`);
+    return true;
+  }
+  if (command === "routing") {
+    state.routingMode = value || "smart";
+    console.log(`routing=${state.routingMode}`);
+    return true;
+  }
+  if (command === "provider") {
+    state.provider = value === "auto" ? "" : value;
+    console.log(`provider=${state.provider || "auto"}`);
+    return true;
+  }
+  if (command === "model") {
+    state.model = value === "auto" ? "" : value;
+    console.log(`model=${state.model || "auto"}`);
+    return true;
+  }
+  if (command === "installs") {
+    state.packageInstallPolicy = normalizePackageInstallPolicy(value || "prompt");
+    console.log(`installs=${state.packageInstallPolicy}`);
+    return true;
+  }
+  if (command === "docker") {
+    if (value === "on") {
+      state.sandboxMode = "docker-workspace";
+      state.packageInstallPolicy = "allow";
+      console.log(`docker=on /workspace -> ${state.commandCwd || process.cwd()} installs=allow`);
+    } else if (value === "off") {
+      state.sandboxMode = "host";
+      state.packageInstallPolicy = "prompt";
+      console.log("docker=off sandbox=host installs=prompt");
+    } else {
+      console.log("Usage: /docker on OR /docker off");
+    }
+    return true;
+  }
+  if (command === "cwd") {
+    state.commandCwd = value || process.cwd();
+    console.log(`cwd=${state.commandCwd}`);
+    return true;
+  }
+  if (command === "init") {
+    const result = await initProject(process.cwd());
+    console.log(`initialized project=${result.projectRoot}`);
+    return true;
+  }
+  if (command === "web") {
+    const port = value || "3220";
+    console.log(`Run in another terminal: aginti web --port ${port}`);
+    return true;
+  }
+
+  console.log(`Unknown command: /${command}. Use /help.`);
+  return true;
+}
+
+async function runPrompt(prompt, state, packageDir) {
+  const config = loadConfig(
+    {
+      provider: state.provider,
+      model: state.model,
+      routingMode: state.routingMode,
+      commandCwd: state.commandCwd,
+      sandboxMode: state.sandboxMode,
+      packageInstallPolicy: state.packageInstallPolicy,
+      allowShellTool: state.allowShellTool,
+      allowFileTools: state.allowFileTools,
+      allowWrapperTools: state.allowWrapperTools,
+      allowDestructive: state.allowDestructive,
+      preferredWrapper: state.preferredWrapper,
+      taskProfile: state.taskProfile,
+      maxSteps: state.maxSteps,
+      headless: state.headless,
+      resume: state.sessionId,
+      goal: prompt,
+    },
+    { packageDir, baseDir: process.cwd() }
+  );
+
+  const result = await runAgent(config);
+  state.sessionId = result.sessionId || state.sessionId;
+}
+
+export async function startInteractiveCli(args = {}, { packageDir, packageVersion } = {}) {
+  const state = createState(args);
+  const rl = readline.createInterface({ input, output, terminal: Boolean(input.isTTY && output.isTTY) });
+
+  console.log(`AgInTiFlow ${packageVersion || ""}`.trim());
+  console.log(`Project: ${process.cwd()}`);
+  console.log("Interactive agent chat. Type /help for commands, /exit to quit.");
+  printStatus(state);
+
+  try {
+    while (true) {
+      let answer = "";
+      try {
+        answer = await rl.question("\naginti> ");
+      } catch (error) {
+        if (error?.code === "ERR_USE_AFTER_CLOSE") break;
+        throw error;
+      }
+      const line = answer.trim();
+      if (!line) continue;
+      if (line.startsWith("/")) {
+        const keepGoing = await handleCommand(line, state, packageDir);
+        if (!keepGoing) break;
+        continue;
+      }
+
+      try {
+        await runPrompt(line, state, packageDir);
+      } catch (error) {
+        console.error(`error: ${error.message}`);
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}