totaljs-totem 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0
+
+The first version.
+
+- **The agent:** reads, searches, edits, patches and runs commands in the folder of a project, and cannot leave it. Every file change and command asks first. Plan mode only reads; Build mode changes things. Diff of each step, undo and redo, background commands, sub-agents, `/commands` and `/init`.
+- **Models:** Ollama, LM Studio and llama.cpp on your computer are detected; OpenRouter, OpenAI, Groq, Mistral, DeepSeek and any OpenAI-compatible server are in the list. The formats of Anthropic and Gemini are written and tested against simulators, not yet with real keys. Small models get a real context in Ollama, a low temperature, a stop to loops and a retry when they answer nothing.
+- **Total.js knowledge:** recipes, the pages of Forge for each request, the conventions as a skill, a check of what is written (syntax, style, invented functions) and a correction of the code in the answers. An evaluation with 29 cases measures it with any model.
+- **Interface:** projects and sessions, streaming chat, copy button on code boxes, attachments, split diff, git state, a terminal with an interactive shell (macOS and Linux), scheduled prompts, sessions in git worktrees, light and dark theme, English, Spanish and Slovak.
+- **Protocols:** a client of MCP tools and prompts, and Totem as an MCP server (off by default).
+- **Security:** secret files ask first, keys and the token never reach the model, a server that listens beyond this computer refuses to start without a token, strict cookie, same-origin checks and security headers.
+- **Delivery:** the `totem` command, a Docker image that runs as a user that is not root, and the package `totaljs-totem` (the data goes to a folder of your user when it is installed from npm).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Spanish Total.js Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,179 @@
-# Temporary Holding Version
+<p align="center">
+  <img src="assets/totem-buttom.svg" alt="Total.js Totem" width="128" height="128">
+</p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<h1 align="center">Total.js Totem</h1>
+
+<p align="center"><b>An AI coding environment written as a Total.js 5 application.</b><br>Open a project, talk to an agent that reads your code, edits files and runs commands, and review every change. You choose the model: one on your computer, a free cloud one, or a paid one.</p>
+
+<p align="center">
+  <a href="https://github.com/totaljs-es/totem/actions/workflows/test.yml"><img src="https://github.com/totaljs-es/totem/actions/workflows/test.yml/badge.svg" alt="Tests"></a>
+  <a href="https://www.npmjs.com/package/totaljs-totem"><img src="https://img.shields.io/npm/v/totaljs-totem" alt="npm version"></a>
+  <img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license">
+  <img src="https://img.shields.io/badge/node-%E2%89%A5%2022-3C873A" alt="Node.js 22 or newer">
+  <img src="https://img.shields.io/badge/Total.js-5-3F8F2A" alt="Total.js 5">
+  <img src="https://img.shields.io/badge/jComponent-20-3F8F2A" alt="jComponent 20">
+  <img src="https://img.shields.io/badge/Docker-ready-2496ED" alt="Docker ready">
+  <img src="https://img.shields.io/badge/languages-en%20%C2%B7%20es%20%C2%B7%20sk-informational" alt="Languages: English, Spanish, Slovak">
+</p>
+
+Totem is one application with three ways to run: a command, a Docker container and (next) a native window. The server is plain Total.js: actions, a few controllers, NoSQL for its own data, and jComponent 20 for the interface. There is no build step.
+
+## What you get
+
+- **An agent with tools.** It reads, searches, edits, patches and runs commands in your project folder, and it cannot leave it (every path is resolved inside the project, symbolic links included).
+- **You stay in control.** Every file change and command asks first, unless you allow it. **Plan mode** only reads and describes; **Build mode** changes things. See the diff of each step, undo it, redo it.
+- **Any model.** Ollama, LM Studio and llama.cpp on your computer are detected for you; OpenRouter, OpenAI, Anthropic, Gemini, Groq, Mistral, DeepSeek and a dozen more (any OpenAI-compatible server) are in the list. Prompts go only to the providers you add.
+- **It knows Total.js.** In a project that depends on `total5` the agent gets the recipes of Totem, the pages of [Forge](https://forge.totaljs.es) for your request, the conventions as a skill, and a check of everything it writes: syntax, style, invented functions. Even a 1.5B model on your laptop answers with real Total.js.
+- **Work in parallel.** Sessions can run in their own **git worktree**, and **scheduled prompts** run by themselves, unattended and read-only unless you say otherwise.
+- **A terminal that stays.** An interactive shell in the project folder that survives a page reload, and background commands the agent can start and read.
+- **Open protocols.** A client of MCP servers (tools and prompts) for the agent, and Totem itself as an MCP server for other agents (off by default).
+- **Careful with your machine.** Secrets never reach the model, `.env` files ask first, a shared server needs a token, and the Docker image runs without root.
+- **Your language.** English, Spanish and Slovak, chosen in Settings.
+
+## Quick start
+
+You need [Node.js](https://nodejs.org) 22 or newer.
+
+```bash
+npm install -g totaljs-totem
+totem
+```
+
+The browser opens on <http://127.0.0.1:8000>. Installed from npm, your data (providers, projects, sessions) lives in a folder of your user (`totem config` prints it) and not in the package, so an update never touches it. To run it from the source instead:
+
+```bash
+git clone https://github.com/totaljs-es/totem.git
+cd totem
+npm install
+node index.js 8000
+```
+
+Press **Settings** and add a model:
+
+- **A model on your computer.** Install [Ollama](https://ollama.com), pull a model (`ollama pull qwen2.5-coder`), and press *Look for servers on this computer*.
+- **A cloud model.** Add a provider, paste the key (it is stored encrypted on your computer and never shown again) and choose the models you want.
+
+Then **Open a folder**, write what you want, and watch it work.
+
+### The command
+
+```bash
+totem                       # starts the server and opens the browser
+totem run "explain this project" --project ~/code/app --model ollama:qwen2.5-coder
+```
+
+(From a clone, `npm link` makes the `totem` command.)
+
+| Command | What it does |
+|---|---|
+| `totem` | Starts the server on port 8000 and opens the browser |
+| `totem serve [port]` | Starts only the server |
+| `totem run "prompt" [options]` | One prompt without the interface: the answer goes to stdout, the tool calls to stderr, the exit code says if it finished |
+| `totem config` | Prints the folders that Totem uses |
+
+Options of `run`: `--project <folder>`, `--model <provider:model>`, `--url <server>`, `--token <token>`, `--auto-accept` (file edits run without asking), `--yes` (every other question is answered "allow once"). Without `--url` a temporary local server is started. `--data <folder>` chooses where the data goes.
+
+### Docker
+
+```bash
+echo "a-long-random-token" > token.txt
+docker run --rm -p 127.0.0.1:8000:8000 \
+  -v "$PWD/token.txt:/run/secrets/totem_token:ro" \
+  -v "$PWD:/workspace/project" \
+  -v totem-data:/data ghcr.io/totaljs-es/totem
+```
+
+(To build it yourself: `docker build -t totem .` in a clone.)
+
+The container listens on all interfaces, so it **refuses to start without an access token**. Your projects are mounted under `/workspace`, the data is a volume, and everything runs as a user that is not root, which makes it the isolated way to try untrusted models. There is a [compose example](docs/docker-compose.yml) and the [delivery notes](docs/delivery.md).
+
+## The interface
+
+| | |
+|---|---|
+| **Projects** | Folders with their sessions. Click one to continue, `+` for a new session, the menu for a named session or one in a **git worktree**. Rename with a double click. |
+| **Chat** | Streaming answers, the thinking of the models that think, a copy button on every code box, attachments (images and text files), the `/commands` of the project and `/init` to write an `AGENTS.md`. |
+| **Changes** | The files the agent changed, unified or split diff, **Undo** and **Redo**, the git state of the folder, and for a worktree session **Merge into the project** or **Discard**. |
+| **Terminal** | The commands the agent ran, the ones in the background, and an interactive **Shell** (macOS and Linux). |
+| **Scheduled prompts** | The clock next to Settings: a prompt every N minutes or every day, in a new session, unattended. |
+| **Settings** | Theme (light, dark, auto), language, providers and models with their abilities. |
+
+## Choose the model
+
+Totem works with a 1.5B model and with the biggest ones. A few tips:
+
+- **Small models on your computer** follow instructions better with a low temperature (`temperature : 0.2` in `config`, already the default for servers on your computer) and enough context: Ollama is asked for at least 16384 tokens, and for more when the request needs it, because its own default silently cuts the instructions.
+- **A model that loops** (repeats one paragraph until the context is full) is stopped by a repeat penalty and a limit per answer (`ollamarepeat`, `ollamapredict`).
+- **Reasoning models** get a *Reasoning* control. The Anthropic and Gemini formats are written and tested against simulators, not yet with real keys: try them and tell us.
+
+## How it knows Total.js
+
+When the project depends on `total5` (or is a new folder), Totem puts three things in front of the model:
+
+1. **Recipes** ([`private/recipes/`](private/recipes)): short, exact answers for the common tasks (routes, actions, NoSQL, config, `RESTBuilder`, auth, CRON, WebSockets, views, jComponent, plugins...), chosen by the words of your request. They work offline and follow the conventions to the letter.
+2. **Forge** ([forge.totaljs.es](https://forge.totaljs.es)): the pages of the documentation that match the request, through MCP. Totem asks before it starts the connection.
+3. **A check of the code**: what the agent writes is checked against the [Total.js conventions](https://github.com/totaljs-es/conventions) (syntax, ES5, tabs, names with `|`, texts as `@(English)`, no invented functions) and the model fixes what is wrong. The code in an answer is checked too, and corrected once.
+
+To measure it with any model:
+
+```bash
+node scripts/knowledge-eval.js --model ollama:qwen2.5:1.5b --runs 3 --out result.json
+```
+
+It asks 29 questions about Total.js and jComponent in a temporary project and scores the answers: what must and must not appear, and the quality of the code. See [knowledge](docs/knowledge.md).
+
+## Configuration
+
+Settings live in the file [`config`](config) (never in environment variables). The ones you will touch:
+
+| Setting | Default | What it does |
+|---|---|---|
+| `$ip` | `127.0.0.1` | The address it listens on. Anything else needs `token` |
+| `token`, `tokenfile` | empty | The access token, or a file that has it (a Docker secret) |
+| `temperature` | `0.2` | For the models on your computer |
+| `ollamactx`, `ollamactxmax` | `16384`, `32768` | Context asked to Ollama |
+| `maxsteps`, `bashtimeout` | `50`, `120000` | Limits of the agent loop |
+| `totaljs` | `auto` | `always` or `never` to decide for every project |
+| `forge`, `recipes`, `selfcheck`, `conventions` | `true` | The parts of the Total.js knowledge |
+| `formatter`, `diagnostics` | `true` | Run the formatter and the checks that the project already has after a write |
+| `terminalshell` | empty | The shell of the Terminal (empty: your `SHELL`) |
+| `$mcp` | `false` | Totem as an MCP server for other agents |
+
+A project can add a `.totem/` folder with `formatters.json`, `diagnostics.json`, `mcp.json`, `instructions.json`, and `agents/`, `commands/` and `skills/`.
+
+## Security in a few lines
+
+- The agent acts through tools only, each checked before it runs. Plan mode refuses writes and commands in code, not in a prompt.
+- Files with secrets (`.env`) ask first; keys and the token are scrubbed from everything the model sees.
+- A server with a token compares it in constant time, uses a strict cookie, refuses requests from other origins, and sends headers against framing.
+- The shell and the commands run with your permissions: they protect against mistakes, not against a hostile model. For that, use the Docker image.
+
+The details, including the honest limits (one token, one user), are in [security](docs/security.md).
+
+## Help
+
+| Problem | What to do |
+|---|---|
+| No model to choose | Settings → add a provider, or *Look for servers on this computer* with Ollama or LM Studio running |
+| A small model seems to ignore the instructions | Check `ollamactx` in `config`: Ollama must get a real context. Totem asks for 16384 by default |
+| The container does not start | It needs a token: mount a file at `/run/secrets/totem_token` (or set `token` in `config`) |
+| "The terminal could not start" | The Shell needs Python 3 (macOS and Linux). It is in the Docker image |
+| Docker cannot see your folder (Colima, Docker Desktop) | Share the folder with the virtual machine: your home folder, not `/tmp` |
+| The agent asks to start Forge | It is the documentation connection. Allow it once for every project, or set `forge : false` |
+| A worktree could not be created | The project needs git with at least one commit |
+| Scheduled prompts do nothing | They run unattended: in Plan mode they only read, and anything that would ask is refused. Choose Build and auto-accept to let them edit |
+
+Run the tests with `npm test` (about 50 seconds, with temporary folders: it never touches your data).
+
+## Status
+
+Phases 1 to 5 of the [roadmap](docs/roadmap.md) are built: the agent and its tools, the interface, the knowledge of Total.js, the terminal, diagnostics, the Docker image, scheduled prompts, worktrees and the hardening of a shared server. Version 0.1.0 is the first one published: the package [`totaljs-totem`](https://www.npmjs.com/package/totaljs-totem) on npm and the image `ghcr.io/totaljs-es/totem` for `linux/amd64` and `linux/arm64`. Still to come: native windows with signed installers (phase 6) and accounts with their own projects. See the [changelog](CHANGELOG.md).
+
+## Documentation
+
+[Vision](docs/vision.md) · [Architecture](docs/architecture.md) · [Agent loop](docs/agent-loop.md) · [Interface](docs/interface.md) · [Protocol](docs/protocol.md) · [Security](docs/security.md) · [Knowledge](docs/knowledge.md) · [Delivery](docs/delivery.md) · [Roadmap](docs/roadmap.md) · [Decisions](docs/decisions.md)
+
+## License
+
+[MIT](LICENSE). Made by the Spanish Total.js Platform.

package/bin/totem.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+'use strict';
+
+// The totem command. It is a tooling script that runs with plain Node.js 22 or newer: it is not part of the Total.js application.
+//
+//   totem                         starts the server and opens the browser
+//   totem serve [port]            starts only the server (default port 8000)
+//   totem run "prompt" [options]  runs one prompt without the interface and prints what happens
+//   totem config                  prints the folders that Totem uses
+//   totem --help
+//
+// Options of run: --project <folder> (default: the current folder), --model <provider:model>, --url <server> (default: a temporary
+// local server), --token <token>, --auto-accept (edits run without asking), --yes (every question is answered "allow once").
+
+var Child = require('child_process');
+var Http = require('http');
+var Net = require('net');
+var Os = require('os');
+var Path = require('path');
+
+var ROOT = Path.join(__dirname, '..');
+
+// Where the data goes. In a clone it stays in the folder of the application (databases/), which is what a developer expects. Installed from npm the
+// folder of the application is not for what changes (it can be read only, and an update replaces it), so the data goes to a folder of the person.
+function datafolder(opt) {
+
+	if (opt && opt.data && opt.data !== true)
+		return Path.resolve(opt.data);
+
+	if (Path.relative(ROOT, __dirname) !== 'bin' || ROOT.split(Path.sep).indexOf('node_modules') === -1)
+		return '';
+
+	var home = Os.homedir();
+
+	if (process.platform === 'darwin')
+		return Path.join(home, 'Library', 'Application Support', 'Totem');
+
+	if (process.platform === 'win32')
+		return Path.join(process.env.APPDATA || Path.join(home, 'AppData', 'Roaming'), 'Totem');
+
+	return Path.join(home, '.local', 'share', 'totem');
+}
+
+exports.datafolder = datafolder;
+
+function usage() {
+	console.log([
+		'Usage:',
+		'  totem                         start the server and open the browser',
+		'  totem serve [port]            start only the server (default port 8000)',
+		'  totem run "prompt" [options]  run a prompt without the interface',
+		'  totem config                  print the folders that Totem uses',
+		'',
+		'Options of run:',
+		'  --project <folder>   the project (default: the current folder)',
+		'  --model <id>         provider:model, as listed in Settings',
+		'  --url <address>      a running server (default: a temporary local server)',
+		'  --token <token>      the access token of the server, when it has one',
+		'  --auto-accept        file edits run without asking',
+		'  --yes                every other question is answered "allow once"',
+		'',
+		'Options of serve and run:',
+		'  --data <folder>      where the data goes (installed from npm: a folder of your user)'
+	].join('\n'));
+}
+
+function options(args) {
+	var out = { _: [] };
+	for (var i = 0; i < args.length; i++) {
+		if (args[i].indexOf('--') === 0) {
+			var key = args[i].substring(2);
+			if (key === 'yes' || key === 'auto-accept' || key === 'help')
+				out[key] = true;
+			else
+				out[key] = args[++i];
+		} else
+			out._.push(args[i]);
+	}
+	return out;
+}
+
+function request(url, token, schema, data) {
+	return new Promise(function(resolve, reject) {
+		var u = new URL('/api/', url);
+		var body = JSON.stringify({ schema: schema, data: data });
+		var headers = { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body) };
+		if (token)
+			headers['x-token'] = token;
+		var req = Http.request({ hostname: u.hostname, port: u.port, path: u.pathname, method: 'POST', headers: headers }, function(res) {
+			var text = '';
+			res.on('data', chunk => text += chunk);
+			res.on('end', function() {
+				var json;
+				try {
+					json = JSON.parse(text);
+				} catch (e) {
+					reject(new Error('Unexpected answer from the server (' + res.statusCode + ')'));
+					return;
+				}
+				if (Array.isArray(json) && json[0] && json[0].error)
+					reject(new Error(json[0].error));
+				else
+					resolve(json);
+			});
+		});
+		req.on('error', reject);
+		req.end(body);
+	});
+}
+
+function freeport() {
+	return new Promise(function(resolve) {
+		var server = Net.createServer();
+		server.listen(0, '127.0.0.1', function() {
+			var port = server.address().port;
+			server.close(() => resolve(port));
+		});
+	});
+}
+
+function serve(port, quiet, data) {
+	var child = Child.spawn(process.execPath, [Path.join(ROOT, 'index.js'), String(port)].concat(data ? ['--data', data] : []), { cwd: ROOT, stdio: quiet ? 'ignore' : 'inherit', detached: true });
+	var stop = function() {
+		try {
+			process.kill(-child.pid);
+		} catch (e) {}
+	};
+	process.on('exit', stop);
+	process.on('SIGINT', () => process.exit(130));
+	process.on('SIGTERM', () => process.exit(143));
+	return { child: child, stop: stop };
+}
+
+async function waitfor(url, token) {
+	for (var i = 0; i < 100; i++) {
+		try {
+			await request(url, token, 'account');
+			return true;
+		} catch (e) {
+			await new Promise(resolve => setTimeout(resolve, 150));
+		}
+	}
+	return false;
+}
+
+function open(url) {
+	var command = process.platform === 'darwin' ? 'open' : (process.platform === 'win32' ? 'cmd' : 'xdg-open');
+	var args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+	Child.spawn(command, args, { stdio: 'ignore', detached: true }).on('error', () => {}).unref();
+}
+
+async function run(opt) {
+
+	var prompt = opt._.slice(1).join(' ');
+	if (!prompt) {
+		console.error('Missing prompt. Usage: totem run "prompt"');
+		return 2;
+	}
+
+	var url = opt.url;
+	var token = opt.token || '';
+	var server = null;
+
+	if (!url) {
+		var port = await freeport();
+		url = 'http://127.0.0.1:' + port;
+		server = serve(port, true, datafolder(opt));
+	}
+
+	if (!await waitfor(url, token)) {
+		console.error('The server does not answer at ' + url);
+		server && server.stop();
+		return 1;
+	}
+
+	var status = 1;
+
+	try {
+
+		var project = await request(url, token, 'projects_open', { path: Path.resolve(opt.project || process.cwd()) });
+		var models = await request(url, token, 'providers_models');
+		var model = opt.model || models[0];
+
+		if (!model) {
+			console.error('No model. Add a provider in the interface (Settings) or pass --model.');
+			return 1;
+		}
+
+		var session = await request(url, token, 'sessions_create', { projectid: project.id, model: model, autoaccept: !!opt['auto-accept'] });
+		var types = {};
+
+		status = await new Promise(function(resolve) {
+
+			var ws = new WebSocket(url.replace(/^http/, 'ws') + '/api/', { headers: token ? { 'x-token': token } : {} });
+			var line = false;
+
+			var finish = code => {
+				if (line)
+					process.stdout.write('\n');
+				resolve(code);
+				try {
+					ws.close();
+				} catch (e) {}
+			};
+
+			ws.onerror = () => {
+				console.error('The event connection failed');
+				finish(1);
+			};
+
+			ws.onopen = function() {
+				ws.send(JSON.stringify({ type: 'subscribe', sessionid: session.id }));
+				setTimeout(() => request(url, token, 'sessions_prompt/' + session.id, { text: prompt }).catch(function(err) {
+					console.error(err.message);
+					finish(1);
+				}), 100);
+			};
+
+			ws.onmessage = function(e) {
+
+				var msg = JSON.parse(e.data);
+				var data = msg.data;
+
+				if (msg.sessionid !== session.id)
+					return;
+
+				if (msg.type === 'part.created')
+					types[data.part.id] = data.part.type;
+
+				if (msg.type === 'part.delta' && types[data.partid] === 'text') {
+					process.stdout.write(data.text);
+					line = true;
+				}
+
+				if (msg.type === 'part.updated' && data.part.type === 'tool' && (data.part.data.status === 'done' || data.part.data.status === 'error' || data.part.data.status === 'denied')) {
+					console.error((line ? '\n' : '') + '[' + data.part.data.tool + '] ' + data.part.data.status + ' ' + JSON.stringify(data.part.data.input).substring(0, 100));
+					line = false;
+				}
+
+				if (msg.type === 'permission.ask') {
+					var allow = opt.yes === true;
+					console.error((line ? '\n' : '') + '[permission] ' + data.tool + ' ' + (data.patterns[0] || '') + ' -> ' + (allow ? 'allowed once' : 'rejected (use --yes or --auto-accept)'));
+					line = false;
+					request(url, token, 'permissions_reply/' + data.id, { reply: allow ? 'once' : 'reject' }).catch(() => {});
+				}
+
+				if (msg.type === 'question.ask') {
+					console.error('[question] ' + data.text + ' -> no user available');
+					request(url, token, 'questions_reply/' + data.id, { answer: '(no user is available to answer: decide yourself)' }).catch(() => {});
+				}
+
+				if (msg.type === 'error')
+					console.error((line ? '\n' : '') + 'error: ' + data.message + (data.retry ? ' (retrying)' : ''));
+
+				if (msg.type === 'session.status' && data.status !== 'running')
+					finish(data.status === 'idle' ? 0 : 1);
+			};
+		});
+
+	} catch (err) {
+		console.error(err.message);
+		status = 1;
+	}
+
+	server && server.stop();
+	return status;
+}
+
+async function main() {
+
+	var args = process.argv.slice(2);
+	var opt = options(args);
+	var command = opt._[0];
+
+	if (opt.help || command === 'help' || args.indexOf('-h') !== -1) {
+		usage();
+		return 0;
+	}
+
+	if (command === 'config') {
+		console.log('Application: ' + ROOT);
+		console.log('Config file: ' + Path.join(ROOT, 'config'));
+		console.log('Data folder: ' + (datafolder(opt) || Path.join(ROOT, 'databases')));
+		return 0;
+	}
+
+	if (command === 'run')
+		return await run(opt);
+
+	if (command === 'serve' || !command) {
+		var port = parseInt(opt._[1] || '8000');
+		var server = serve(port, false, datafolder(opt));
+		if (!command) {
+			var url = 'http://127.0.0.1:' + port + '/';
+			if (await waitfor(url))
+				open(url);
+		}
+		await new Promise(resolve => server.child.on('exit', resolve));
+		return 0;
+	}
+
+	console.error('Unknown command: ' + command);
+	usage();
+	return 2;
+}
+
+if (require.main === module) {
+	main().then(code => process.exit(code), function(err) {
+		console.error(err.message);
+		process.exit(1);
+	});
+}

package/config

@@ -0,0 +1,66 @@
+name                        : Total.js Totem
+version                     : 0.1.0
+$api                        : /api/
+
+// The address the server listens on. Only this computer by default; anything else (0.0.0.0 in the Docker image) needs `token`, and the server refuses to start without one
+$ip                         : 127.0.0.1
+$tmsmaxsize                 : 0
+
+// Totem as an MCP server (POST /$mcp/): other agents can list projects and sessions and send prompts. Off by default. With a token it asks for
+// `Authorization: Bearer <token>`; without one only programs of this computer (localhost) are accepted, never a web page.
+$mcp                        : false
+
+// A random secret is generated and saved in the data folder on first start when empty
+secret                      :
+
+// When set, every request must send it (header x-token or the cookie created by /auth/)
+token                       :
+
+// A file with the access token (a Docker secret), read when `token` is empty
+tokenfile                   :
+
+// Temperature for the models that run on this computer (a low one keeps a small model to the instructions). Remote providers use their own.
+temperature       (Number)  : 0.2
+
+// Ollama is asked for a context of at least this many tokens, and for more when the request needs it, up to the second number or the window of the
+// model. Its default context is 2048 or 4096 tokens, which cuts the instructions of Totem.
+ollamactx         (Number)  : 16384
+ollamactxmax      (Number)  : 32768
+
+// A small model can fall into a loop and repeat a paragraph until the context is full. Ollama is asked to penalize repeating (1 is off) and to stop one
+// answer after this many tokens (0 is no limit).
+ollamarepeat      (Number)  : 1.1
+ollamapredict     (Number)  : 8192
+
+// Agent limits
+maxsteps          (Number)  : 50
+bashtimeout       (Number)  : 120000
+maxoutput         (Number)  : 30000
+contextlimit      (Number)  : 100000
+retries           (Number)  : 3
+retrybase         (Number)  : 1000
+
+// Totem writes Total.js unless the project is clearly something else: auto, always or never
+totaljs                     : auto
+
+// The knowledge that Totem brings to Total.js 5 projects: the documentation of Forge (asks before it starts) and the check of the conventions
+forge                       : true
+// How many pages of Forge are read for a prompt, and how many characters of each
+// The recipes of Totem (private/recipes) that go in front of the model for a request about Total.js 5: how many at most, and false to turn them off
+recipes                     : true
+
+// The code in the answer of the model is checked against the conventions (syntax, style, invented functions) and the model corrects it once. false turns it off.
+selfcheck                   : true
+reciperesults     (Number)  : 2
+forgepages        (Number)  : 2
+forgechars        (Number)  : 3500
+conventions                 : true
+
+// Run the formatter of the project (a local prettier, gofmt, rustfmt, ruff or .totem/formatters.json) after a file is written
+formatter                   : true
+
+// Run the checks of the project (node --check, a local tsc, go vet, cargo check, ruff or .totem/diagnostics.json) after a file is written and tell the model what is wrong
+diagnostics                 : true
+
+// The shell of the interactive terminal (empty: the SHELL of the user, or /bin/sh)
+terminalshell               :