@truss-harness/cli 0.1.0 → 0.1.2

package/README.md

@@ -23,13 +23,17 @@ truss-cli
 truss-cli help
 ```
 
+## Interactive setup
+
+Run truss-cli setup after installation to discover local servers, choose a model, and save a default user-level profile. It is a command rather than an install-time prompt, so npm installs remain safe in CI and scripts.
+
 ## First run
 
 Start your local model server, open a terminal in the project you want Truss to work on, and run:
 
 ```sh
 truss-cli models
-truss-cli chat "Explain this workspace"
+truss-cli chat --mode edit "Explain this workspace"
 ```
 
 Truss probes the standard Ollama, LM Studio, and llama.cpp endpoints when no model is configured. Create a reusable workspace profile when you want explicit settings:
@@ -50,6 +54,16 @@ truss-cli chat --internet-access "Check the current library documentation"
 
 Direct CLI chat is non-interactive and auto-allows registered tools. Run it only in a trusted workspace. Public internet tools are disabled unless `--internet-access`, a profile, or the environment explicitly enables them.
 
+## Persistent chat
+
+Run `truss-cli chat` without a prompt to keep one local conversation open. The configuration flags supplied when it starts remain active, and history remains available as you send messages.
+
+```sh
+truss-cli chat --mode edit --permission auto-read
+```
+
+Use `:mode chat`, `:mode plan`, or `:mode edit` to change the active mode. You can also prefix a message with `--mode edit`, for example `--mode edit Inspect the repository and explain it.` The mode change persists for the rest of that conversation. Use `:clear` for a fresh conversation, `:help` for controls, and `:exit` to close it.
+
 ## Workspace commands
 
 These deterministic commands work without a configured model:

package/dist/bin.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { cwd } from "node:process";
+import { createInterface } from "node:readline/promises";
 import { detectLocalEndpoints, listLocalModels } from "@truss-harness/provider-openai-compatible";
 import { brand } from "@truss-harness/branding";
 import { executeWorkspaceCommand, workspaceCommandHelp } from "@truss-harness/runtime";
 import { createClientRuntime } from "./runtime.js";
-import { configurationPaths, initializeWorkspaceConfiguration, parseConfigurationOverrides, resolveConfiguration } from "./config.js";
+import { configurationPaths, initializeWorkspaceConfiguration, parseConfigurationOverrides, resolveConfiguration, saveUserProfile } from "./config.js";
 import { ProtocolToolApproval, runService } from "./protocol.js";
 const help = `${brand.productName} CLI
 
@@ -16,11 +17,14 @@ Usage:
 Quick start:
   1. Start Ollama, LM Studio, llama.cpp, or a compatible local server.
   2. Run: ${brand.cliCommand} models
-  3. Run: ${brand.cliCommand} chat "Explain this workspace"
-  4. Optional: ${brand.cliCommand} config init
+ 3. Run: ${brand.cliCommand} chat "Explain this workspace"
+  3. Run: ${brand.cliCommand} setup
+  4. Run: ${brand.cliCommand} chat --mode edit
+  5. Optional: ${brand.cliCommand} config init
 
 Commands:
-  chat <prompt>          Stream one agent response in the current workspace
+  chat [prompt]          Stream one response or open persistent chat
+  setup                 Interactively choose and save local-model defaults
   models                List detected local servers and models
   config path           Print user and workspace configuration paths
   config init           Create a workspace configuration template
@@ -74,6 +78,149 @@ Examples:
 
 ${workspaceCommandHelp()}
 `;
+function subscribeToRuntimeEvents(events) {
+    events.subscribe((event) => {
+        if (event.type === "text_delta")
+            process.stdout.write(event.text);
+        if (event.type === "tool_call_requested")
+            process.stderr.write("\n[tool] " + event.tool + "\n");
+        if (event.type === "plan_updated") {
+            const steps = event.plan.steps.map((step) => "  " + (step.status === "completed" ? "[x]" : step.status === "in_progress" ? "[..]" : "[ ]") + " " + step.content).join("\n");
+            process.stderr.write("\n[plan] " + event.plan.title + "\n" + steps + "\n");
+        }
+    });
+}
+function inlineMode(input) {
+    const match = input.trim().match(/^--mode\s+(chat|plan|edit)(?:\s+([\s\S]*))?$/);
+    return match ? { mode: match[1], prompt: match[2]?.trim() ?? "" } : { prompt: input.trim() };
+}
+async function runInteractiveChat(initialConfiguration) {
+    let configuration = initialConfiguration;
+    let client = await createClientRuntime(configuration);
+    let session = await client.runtime.createSession();
+    let messages = session.messages;
+    subscribeToRuntimeEvents(client.events);
+    const readline = createInterface({ input: process.stdin, output: process.stdout, terminal: process.stdin.isTTY === true });
+    process.stdout.write(brand.productName + " interactive chat. :help for controls. Mode: " + configuration.mode + ".\n");
+    const replaceRuntime = async (mode) => {
+        const current = await client.runtime.getSession(session.id);
+        messages = current?.messages ?? messages;
+        await client.dispose();
+        configuration = { ...configuration, mode };
+        client = await createClientRuntime(configuration);
+        session = await client.runtime.createSession(messages);
+        subscribeToRuntimeEvents(client.events);
+        process.stdout.write("\n[mode: " + mode + "]\n");
+    };
+    try {
+        while (true) {
+            const line = await readline.question(brand.cliCommand + " (" + configuration.mode + ") > ").catch(() => undefined);
+            if (line === undefined)
+                break;
+            const input = line.trim();
+            if (!input)
+                continue;
+            if (input === ":exit" || input === ":quit")
+                break;
+            if (input === ":help") {
+                process.stdout.write("Controls: :mode chat|plan|edit, :clear, :exit. You can also prefix a message with --mode chat|plan|edit.\n");
+                continue;
+            }
+            if (input === ":clear") {
+                session = await client.runtime.createSession();
+                messages = session.messages;
+                process.stdout.write("[conversation cleared]\n");
+                continue;
+            }
+            const modeCommand = input.match(/^:mode\s+(chat|plan|edit)$/);
+            if (modeCommand) {
+                await replaceRuntime(modeCommand[1]);
+                continue;
+            }
+            if (input.startsWith(":mode")) {
+                process.stdout.write("Use :mode chat, :mode plan, or :mode edit.\n");
+                continue;
+            }
+            const next = inlineMode(input);
+            if (next.mode && next.mode !== configuration.mode)
+                await replaceRuntime(next.mode);
+            if (!next.prompt)
+                continue;
+            const workspaceCommand = await executeWorkspaceCommand({ workspaceRoot: cwd(), input: next.prompt });
+            if (workspaceCommand.handled) {
+                process.stdout.write(workspaceCommand.message + "\n");
+                continue;
+            }
+            try {
+                await client.runtime.run(session.id, next.prompt);
+                process.stdout.write("\n");
+            }
+            catch (error) {
+                process.stderr.write("\n" + (error instanceof Error ? error.message : String(error)) + "\n");
+            }
+        }
+    }
+    finally {
+        readline.close();
+        await client.dispose();
+    }
+}
+function selectedIndex(input, count, fallback) {
+    const index = Number.parseInt(input, 10);
+    return Number.isInteger(index) && index >= 1 && index <= count ? index - 1 : fallback;
+}
+async function runSetup() {
+    const readline = createInterface({ input: process.stdin, output: process.stdout, terminal: process.stdin.isTTY === true });
+    const ask = async (label, fallback) => {
+        const answer = (await readline.question(label + " [" + fallback + "]: ")).trim();
+        return answer || fallback;
+    };
+    try {
+        const endpoints = await detectLocalEndpoints();
+        process.stdout.write(brand.productName + " setup\n");
+        process.stdout.write("Choose a local model server. Values in brackets are defaults.\n\n");
+        endpoints.forEach((endpoint, index) => process.stdout.write(String(index + 1) + ". " + endpoint.label + " (" + endpoint.baseUrl + ")\n"));
+        process.stdout.write(String(endpoints.length + 1) + ". Custom endpoint\n");
+        const endpointChoice = selectedIndex(await ask("Server", "1"), endpoints.length + 1, 0);
+        let endpoint;
+        if (endpointChoice < endpoints.length) {
+            endpoint = endpoints[endpointChoice];
+        }
+        else {
+            const provider = await ask("Provider: ollama or openai-compatible", "openai-compatible");
+            if (provider !== "ollama" && provider !== "openai-compatible")
+                throw new Error("Provider must be ollama or openai-compatible.");
+            const fallbackUrl = provider === "ollama" ? "http://127.0.0.1:11434" : "http://127.0.0.1:1234/v1";
+            endpoint = { id: "custom", label: "Custom endpoint", kind: provider, baseUrl: await ask("Endpoint URL", fallbackUrl) };
+        }
+        const models = await listLocalModels(endpoint).catch(() => []);
+        models.forEach((model, index) => process.stdout.write(String(index + 1) + ". " + model.name + "\n"));
+        const model = models.length
+            ? models[selectedIndex(await ask("Model", "1"), models.length, 0)].name
+            : await ask("Model ID", "local-model");
+        const profileName = await ask("Profile name", endpoint.id === "custom" ? "local" : endpoint.id);
+        const mode = await ask("Default mode: chat, plan, or edit", "edit");
+        if (mode !== "chat" && mode !== "plan" && mode !== "edit")
+            throw new Error("Mode must be chat, plan, or edit.");
+        const permission = await ask("Default permission: ask, auto-read, or auto-all", "auto-read");
+        if (permission !== "ask" && permission !== "auto-read" && permission !== "auto-all")
+            throw new Error("Permission must be ask, auto-read, or auto-all.");
+        const internet = await ask("Enable internet research: yes or no", "no");
+        const path = await saveUserProfile(cwd(), profileName, {
+            provider: endpoint.kind,
+            baseUrl: endpoint.baseUrl,
+            model,
+            mode,
+            permission,
+            internetAccess: /^(y|yes|true|1)$/i.test(internet)
+        });
+        process.stdout.write("\nSaved profile '" + profileName + "' to " + path + "\n");
+        process.stdout.write("Start a persistent session with: " + brand.cliCommand + " chat --profile " + profileName + "\n");
+    }
+    finally {
+        readline.close();
+    }
+}
 async function main() {
     const [command = "help", ...rawArgs] = process.argv.slice(2);
     if (command === "help" || command === "--help" || command === "-h") {
@@ -86,6 +233,10 @@ async function main() {
         process.stdout.write(`${JSON.stringify(models, null, 2)}\n`);
         return;
     }
+    if (command === "setup") {
+        await runSetup();
+        return;
+    }
     if (command === "config") {
         const [action = "path"] = rawArgs;
         const paths = configurationPaths(cwd());
@@ -113,7 +264,7 @@ async function main() {
             process.exitCode = 1;
         return;
     }
-    if (command === "chat") {
+    if (command === "chat" && args.length) {
         const prompt = args.join(" ").trim();
         if (!prompt)
             throw new Error(`Provide a prompt: ${brand.cliCommand} chat <prompt>`);
@@ -140,6 +291,10 @@ async function main() {
         }
         return;
     }
+    if (command === "chat" && !args.join(" ").trim()) {
+        await runInteractiveChat(configuration);
+        return;
+    }
     const client = await createClientRuntime(configuration);
     const { runtime, events } = client;
     for (const server of client.mcpServers) {

package/dist/config.d.ts

@@ -43,6 +43,8 @@ export declare function resolveConfiguration(options: {
     readonly paths?: ConfigurationPaths;
 }): Promise<ResolvedConfiguration>;
 export declare function initializeWorkspaceConfiguration(workspaceRoot: string, paths?: ConfigurationPaths): Promise<string>;
+/** Saves a selected local-model profile in the user configuration file. */
+export declare function saveUserProfile(workspaceRoot: string, profileName: string, profile: ProfileConfiguration, paths?: ConfigurationPaths): Promise<string>;
 export declare function parseConfigurationOverrides(arguments_: readonly string[]): {
     readonly overrides: ConfigurationOverrides;
     readonly rest: readonly string[];

package/dist/config.js

@@ -208,6 +208,20 @@ export async function initializeWorkspaceConfiguration(workspaceRoot, paths = co
     }, null, 2)}\n`, "utf8");
     return paths.workspace;
 }
+/** Saves a selected local-model profile in the user configuration file. */
+export async function saveUserProfile(workspaceRoot, profileName, profile, paths = configurationPaths(workspaceRoot)) {
+    const existing = await readConfiguration(paths.user);
+    await mkdir(dirname(paths.user), { recursive: true });
+    await writeFile(paths.user, JSON.stringify({
+        ...existing,
+        defaultProfile: profileName,
+        profiles: {
+            ...existing.profiles,
+            [profileName]: profile
+        }
+    }, null, 2) + "\n", "utf8");
+    return paths.user;
+}
 export function parseConfigurationOverrides(arguments_) {
     const overrides = {};
     const rest = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truss-harness/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Command-line client and runtime service for Truss.",
   "type": "module",
   "exports": {
@@ -14,7 +14,7 @@
     }
   },
   "bin": {
-    "truss-cli": "./dist/bin.js"
+    "truss-cli": "dist/bin.js"
   },
   "scripts": {
     "build": "tsc -b",

package/scripts/postinstall.mjs

@@ -3,9 +3,8 @@ if (process.env.npm_config_global === "true" || process.env.npm_config_global ==
 Truss CLI installed.
 
 Next steps:
-  truss-cli models
-  truss-cli config init
-  truss-cli chat "Explain this workspace"
+  truss-cli setup
+  truss-cli chat --mode edit
 
 Run truss-cli help for modes, permissions, configuration, and examples.
 `);