@alisio/alisio-code 0.1.0-alpha.3

package/dist/main.js

@@ -0,0 +1,476 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+const VERSION = "0.1.0-alpha.1";
+function parseAgents(json) {
+    const value = JSON.parse(json);
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error('--agents expects a JSON object: {"name":{"description":"...","prompt":"..."}}');
+    return value;
+}
+/** Built-in plugins and prompt templates, and the slash names templates may not take. */
+async function cliDefaults() {
+    const [{ BUILTIN_PLUGINS }, { BUILTIN_PROMPTS }, { reservedCommandNames }] = await Promise.all([
+        import("./builtin.js"),
+        import("./prompts/index.js"),
+        import("./tui/state.js"),
+    ]);
+    return {
+        builtins: BUILTIN_PLUGINS,
+        builtinPrompts: BUILTIN_PROMPTS,
+        reservedPromptNames: reservedCommandNames(),
+    };
+}
+const program = new Command();
+program
+    .name("alisio")
+    .description("Velocidad y eficiencia para construir — extensible coding harness")
+    .version("0.1.0-alpha.1")
+    .option("--cwd <path>", "Working directory")
+    .option("--config <path>", "Explicit trusted configuration file")
+    .option("--trust-project", "Load project config and executable plugins (full process privileges)")
+    .option("--plugin <path...>", "Load explicitly trusted local plugins")
+    .option("--model <id>", "Provider model ID")
+    .option("--base-url <url>", "OpenAI-compatible API base URL, including /v1 if needed")
+    .option("--api-mode <mode>", "chat or responses")
+    .option("--allow-write", "Allow file writes")
+    .option("--allow-process", "Allow arbitrary subprocesses; not sandboxed")
+    .option("--allow-external", "Allow network tools: webfetch, websearch and provider-native search")
+    .option("--allow-mcp", "Allow configured MCP servers and remote tool calls")
+    .option("--allow-agents", "Allow messaging neighboring agents through Herdr")
+    .option("--no-herdr", "Disable automatic Herdr lifecycle reports")
+    .option("--read-only", "Disable writes, arbitrary processes, network tools, executable plugins and MCP")
+    .option("--db <path>", "Session database")
+    .option("--json", "Emit versioned JSONL events")
+    .option("--no-tui", "Use the plain readline interactive mode instead of the TUI")
+    .option("--disable-plugin <ids...>", "Disable built-in plugins (for example: memory)")
+    .option("--no-banner", "Do not show the startup screen")
+    .option("--agents <json>", 'Extra subagent definitions as JSON: {"name":{"description":"...","prompt":"..."}}')
+    .option("--quiet", "Suppress non-essential output (startup screen, hints)");
+const options = (cmd) => {
+    const o = cmd.optsWithGlobals();
+    return {
+        ...o,
+        baseURL: o.baseUrl,
+        noHerdr: o.herdr === false,
+        disablePlugins: o.disablePlugin,
+        ...(o.agents
+            ? { pluginOptions: { subagents: { agents: parseAgents(String(o.agents)) } } }
+            : {}),
+    };
+};
+/**
+ * A one-time, plain (pre-alt-screen) yes/no prompt. It must run before the TUI (and before
+ * `createApplication`, which is what actually reads `.alisio/config.json`) exists, since the
+ * decision made here controls whether that read happens at all — the TUI's own interactive
+ * question queue is built from an already-created Application, too late for this.
+ */
+async function promptTrust(workspace) {
+    const { createInterface } = await import("node:readline/promises");
+    process.stderr.write(`\nThis directory has Alisio project configuration: ${workspace}\n` +
+        "Trusting it lets Alisio load that configuration for this and future runs — including a " +
+        "possibly different provider endpoint or API key — plus its plugins, agents, skills and " +
+        "prompt templates. Declining uses Alisio's own defaults instead; nothing here is read.\n");
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        const answer = (await rl.question("Trust this project's Alisio configuration? [y/N] "))
+            .trim()
+            .toLowerCase();
+        return answer === "y" || answer === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Resolves the effective `trustProject` for an interactive TUI run: an explicit
+ * `--trust-project`/`--config` is untouched (that is already one-run, explicit trust, never
+ * persisted here as though it were an interactive grant). Otherwise, a workspace with project
+ * resources to trust gets a one-time prompt (re-asked only when `.alisio/config.json` changes),
+ * persisted in the trust store; a workspace with nothing to trust is never prompted at all.
+ */
+async function withProjectTrust(opts) {
+    if (opts.trustProject || opts.config)
+        return opts;
+    const { findWorkspace, resolveTrust, setTrust } = await import("@alisio/core");
+    const workspace = await findWorkspace(opts.cwd ?? process.cwd());
+    const resolution = await resolveTrust(workspace);
+    if (!resolution.hasProjectResources)
+        return opts;
+    if (!resolution.needsPrompt)
+        return { ...opts, trustProject: resolution.trusted };
+    const trusted = await promptTrust(workspace);
+    await setTrust(workspace, trusted, resolution.configHash);
+    return { ...opts, trustProject: trusted };
+}
+async function run(cmd, prompt, sessionId) {
+    const opts = options(cmd);
+    if (!prompt &&
+        !opts.json &&
+        opts.tui !== false &&
+        process.stdin.isTTY &&
+        process.stdout.isTTY) {
+        const { runTui } = await import("./tui/app.js");
+        const trusted = await withProjectTrust(opts);
+        return runTui({ ...trusted, ...(sessionId ? { session: sessionId } : {}) });
+    }
+    const { createApplication } = await import("@alisio/core");
+    const app = await createApplication({
+        ...(await cliDefaults()),
+        ...opts,
+        onEvent: (event) => {
+            if (opts.json)
+                process.stdout.write(`${JSON.stringify(event)}\n`);
+            else if (event.type === "text_delta")
+                process.stdout.write(String(event.data.delta));
+            else if (event.type === "tool_started")
+                process.stderr.write(`\n→ ${event.data.name}\n`);
+        },
+    });
+    const controller = new AbortController();
+    const interrupt = () => controller.abort(new Error("Interrupted"));
+    process.on("SIGINT", interrupt);
+    // `/name args` runs a prompt template (same syntax as the TUI); refuse before creating a session.
+    let template;
+    try {
+        template = prompt ? app.expandPrompt(prompt) : undefined;
+    }
+    catch (error) {
+        await app.close();
+        throw error;
+    }
+    let session = sessionId ?? app.store.create(app.workspace, app.provider.id, app.provider.model).id;
+    try {
+        // Sessions record their model; an explicit --model switches it for the next turns.
+        if (sessionId && opts.model && app.store.get(session).model !== opts.model)
+            app.runner.setModel(session, opts.model);
+        await app.herdr.report("idle", session);
+        if (prompt) {
+            const match = /^\/skill:([a-z0-9-]+)\s*([\s\S]*)$/.exec(prompt);
+            if (match?.[1])
+                prompt = `${await app.skills.load(match[1])}\n\nUser request: ${match[2] ?? ""}`;
+            await app.runner.run(session, template?.text ?? prompt, controller.signal, template ? { display: template.display } : {});
+            if (!opts.json)
+                process.stdout.write(`\nSession: ${session}\n`);
+            return;
+        }
+        if (opts.json || !process.stdin.isTTY)
+            throw new Error("Provide a prompt with run, or use an interactive terminal");
+        const { createInterface } = await import("node:readline/promises");
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.on("SIGINT", interrupt);
+        controller.signal.addEventListener("abort", () => rl.close(), { once: true });
+        const { bannerPolicy, startupInput, terminalCapabilities } = await import("./banner.js");
+        if (bannerPolicy({
+            mode: "readline",
+            ...opts,
+            stdoutTTY: !!process.stdout.isTTY,
+            stderrTTY: !!process.stderr.isTTY,
+            env: process.env,
+        })) {
+            const { renderStartup } = await import("@alisio/core");
+            const terminal = terminalCapabilities({
+                env: process.env,
+                columns: process.stderr.columns ?? 80,
+                tty: true,
+            });
+            const banner = renderStartup(app.plugins, startupInput(app, { version: VERSION, readOnly: !!opts.readOnly, terminal }));
+            process.stderr.write(`${banner.lines.join("\n")}\n`);
+            for (const d of banner.diagnostics)
+                process.stderr.write(`[startup] ${JSON.stringify(d)}\n`);
+        }
+        if (!opts.quiet)
+            console.log("Alisio · /exit /new /skill:name /command plugin.id:name args");
+        process.stdout.write("\nalisio › ");
+        try {
+            for await (const rawLine of rl) {
+                if (controller.signal.aborted)
+                    break;
+                const line = rawLine.trim();
+                if (!line)
+                    continue;
+                if (line === "/exit")
+                    break;
+                if (line === "/new") {
+                    session = app.store.create(app.workspace, app.provider.id, app.provider.model).id;
+                    await app.herdr.report("idle", session);
+                    process.stdout.write("\nalisio › ");
+                    continue;
+                }
+                if (line.startsWith("/command ")) {
+                    const [name, ...args] = line.slice(9).split(" ");
+                    const handler = app.plugins.commands.get(name ?? "");
+                    if (!handler)
+                        throw new Error("Unknown plugin command");
+                    console.log(await handler(args.join(" ")));
+                    continue;
+                }
+                const match = /^\/skill:([a-z0-9-]+)\s*([\s\S]*)$/.exec(line);
+                const input = match?.[1] ? `${await app.skills.load(match[1])}\n\n${match[2] ?? ""}` : line;
+                try {
+                    const template = app.expandPrompt(input);
+                    await app.runner.run(session, template?.text ?? input, controller.signal, template ? { display: template.display } : {});
+                }
+                catch (e) {
+                    console.error(String(e));
+                }
+                process.stdout.write("\nalisio › ");
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    finally {
+        process.off("SIGINT", interrupt);
+        await app.close();
+    }
+}
+program
+    .command("run")
+    .description('Run one prompt headless; "/name args" runs a prompt template (e.g. "/init")')
+    .argument("<prompt>")
+    .action((prompt, _options, cmd) => run(cmd, prompt));
+program
+    .command("resume")
+    .argument("<session>")
+    .argument("[prompt]")
+    .action((id, prompt, _opts, cmd) => run(cmd, prompt, id));
+program.action((_opts, cmd) => run(cmd));
+program
+    .command("setup")
+    .description("Write an example configuration without secrets (for AGENTS.md use /init)")
+    .action(async (_opts, cmd) => {
+    const { resolve, join } = await import("node:path");
+    const { mkdir, writeFile } = await import("node:fs/promises");
+    const { exists } = await import("@alisio/core");
+    const path = join(resolve(options(cmd).cwd ?? process.cwd()), ".alisio", "config.json");
+    if (await exists(path))
+        throw new Error(`Configuration exists: ${path}`);
+    await mkdir(join(path, ".."), { recursive: true });
+    await writeFile(path, `${JSON.stringify({ schemaVersion: 1, provider: { baseURL: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY", model: "YOUR_MODEL_ID", apiMode: "chat", auth: "bearer", tokenParameter: "max_tokens", streamUsage: false }, plugins: [], skills: [], mcp: { servers: {} } }, null, 2)}\n`);
+    console.log(`Created ${path}. Set your model, endpoint and environment key. Use --config ${path}.`);
+    console.log('To generate AGENTS.md for this project, run /init inside alisio (or: alisio run "/init" --allow-write).');
+});
+program.command("doctor").action(async (_opts, cmd) => {
+    const { findWorkspace, loadConfigWithProvenance, overridesSavedProviderProfile, ProviderSettingsStore, which, } = await import("@alisio/core");
+    const o = options(cmd);
+    const workspace = await findWorkspace(o.cwd ?? process.cwd());
+    const { config, provenance } = await loadConfigWithProvenance(workspace, {
+        file: o.config,
+        trustProject: o.trustProject,
+        model: o.model,
+        baseURL: o.baseURL,
+        apiMode: o.apiMode,
+    });
+    const saved = await new ProviderSettingsStore().active();
+    const useSaved = !!saved &&
+        !overridesSavedProviderProfile(provenance, !!o.baseURL || !!o.apiMode || !!process.env.OPENAI_BASE_URL || !!process.env.ALISIO_API_MODE);
+    const model = o.model?.trim() ||
+        process.env.ALISIO_MODEL?.trim() ||
+        (useSaved ? saved.profile.model : config.provider.model);
+    const status = {
+        version: "0.1.0-alpha.1",
+        runtime: process.versions.bun ? `bun ${process.versions.bun}` : `node ${process.versions.node}`,
+        platform: process.platform,
+        workspace,
+        git: (await which("git")) ?? null,
+        ripgrep: (await which("rg")) ?? null,
+        provider: {
+            id: useSaved ? saved.profile.provider : "openai-compatible",
+            baseURL: useSaved ? saved.profile.values.baseURL : config.provider.baseURL,
+            apiMode: useSaved ? saved.profile.values.apiMode : config.provider.apiMode,
+            model: !model
+                ? "not configured"
+                : model === "YOUR_MODEL_ID"
+                    ? "not configured (placeholder from `alisio setup` — edit .alisio/config.json)"
+                    : model,
+            auth: useSaved ? saved.profile.values.auth : config.provider.auth,
+            keyConfigured: useSaved
+                ? !!saved.credentials.apiKey || saved.profile.values.auth === "none"
+                : config.provider.auth === "none" || !!process.env[config.provider.apiKeyEnv],
+        },
+    };
+    console.log(JSON.stringify(status, null, 2));
+    if (!model || model === "YOUR_MODEL_ID")
+        console.error("\nNo model configured yet: set provider.model in your config, --model, or ALISIO_MODEL " +
+            "before starting a real conversation (it will otherwise fail on the first turn).");
+});
+const trust = program.command("trust").description("Inspect or revoke per-directory project trust");
+trust.command("list").action(async () => {
+    const { listTrust } = await import("@alisio/core");
+    console.log(JSON.stringify(await listTrust(), null, 2));
+});
+trust
+    .command("revoke")
+    .argument("<path>")
+    .description("Revoke a workspace's stored trust decision (re-prompts next time)")
+    .action(async (path) => {
+    const { revokeTrust } = await import("@alisio/core");
+    const { resolve } = await import("node:path");
+    const { realpath } = await import("node:fs/promises");
+    const workspace = await realpath(resolve(path)).catch(() => resolve(path));
+    const removed = await revokeTrust(workspace);
+    console.log(removed ? `Revoked trust for ${workspace}` : `No stored trust decision for ${workspace}`);
+});
+const sessions = program.command("sessions");
+async function openStore(cmd) {
+    const { SQLiteStore } = await import("@alisio/core");
+    const { stateHome } = await import("@alisio/core");
+    const { join } = await import("node:path");
+    return new SQLiteStore(options(cmd).db ?? join(stateHome(), "sessions.sqlite"));
+}
+sessions.command("list").action(async (_opts, cmd) => {
+    const store = await openStore(cmd);
+    try {
+        console.log(JSON.stringify(store.list(), null, 2));
+    }
+    finally {
+        store.close();
+    }
+});
+sessions
+    .command("recover")
+    .argument("<session>")
+    .requiredOption("--acknowledge", "Acknowledge uncertain effects after inspecting the workspace")
+    .action(async (id, _opts, cmd) => {
+    const store = await openStore(cmd);
+    try {
+        store.acquire(id);
+        try {
+            store.reconcile(id, true);
+        }
+        finally {
+            store.release(id);
+        }
+        console.log("Session recovered. Uncertain operations were not replayed.");
+    }
+    finally {
+        store.close();
+    }
+});
+program
+    .command("context")
+    .command("explain")
+    .argument("<path>")
+    .action(async (path, _opts, cmd) => {
+    const { ProjectContext } = await import("@alisio/core");
+    const { findWorkspace } = await import("@alisio/core");
+    const { resolve } = await import("node:path");
+    const cwd = resolve(options(cmd).cwd ?? process.cwd());
+    const root = await findWorkspace(cwd);
+    console.log(JSON.stringify(await new ProjectContext(root).explain(resolve(cwd, path)), null, 2));
+});
+const skills = program.command("skills");
+for (const name of ["list", "validate"]) {
+    skills
+        .command(name)
+        .argument("[path]")
+        .action(async (path, _opts, cmd) => {
+        const { Skills, configHome, findWorkspace, loadConfig, skillRoots } = await import("@alisio/core");
+        const { resolve } = await import("node:path");
+        const { homedir } = await import("node:os");
+        const o = options(cmd), cwd = resolve(o.cwd ?? process.cwd()), root = await findWorkspace(cwd);
+        const config = await loadConfig(root, { file: o.config, trustProject: o.trustProject });
+        const roots = skillRoots({
+            workspace: root,
+            cwd,
+            home: homedir(),
+            configHome: configHome(),
+            trusted: !!o.trustProject || !!o.config,
+            configSkills: config.skills,
+        });
+        const catalog = new Skills({ overrides: path ? {} : config.skillOverrides });
+        await catalog.discover(path ? [resolve(cwd, path)] : roots);
+        console.log(JSON.stringify({ skills: [...catalog.items.values()], diagnostics: catalog.diagnostics }, null, 2));
+        if (name === "validate" && catalog.diagnostics.length)
+            process.exitCode = 1;
+    });
+}
+const plugins = program.command("plugins");
+plugins.command("list").action(async (_opts, cmd) => {
+    const { discoverPlugins } = await import("@alisio/core");
+    const { configHome } = await import("@alisio/core");
+    const { join, resolve } = await import("node:path");
+    console.log(JSON.stringify({
+        global: await discoverPlugins(join(configHome(), "plugins")),
+        project: await discoverPlugins(join(resolve(options(cmd).cwd ?? process.cwd()), ".alisio", "plugins")),
+        explicit: options(cmd).plugin ?? [],
+    }, null, 2));
+});
+plugins.command("doctor").action(async (_opts, cmd) => {
+    const { createApplication } = await import("@alisio/core");
+    const app = await createApplication({
+        ...(await cliDefaults()),
+        ...options(cmd),
+        provider: {
+            id: "inspection",
+            model: "none",
+            stream() {
+                throw new Error("Inspection provider cannot run prompts");
+            },
+        },
+    });
+    try {
+        console.log(JSON.stringify({
+            tools: app.registry
+                .list()
+                .filter((t) => t.name.startsWith("p_"))
+                .map((t) => t.name),
+            extensions: {
+                mascot: app.plugins.extensions.resolve("mascot")?.provider.id ?? "alisio.default",
+                startupScreen: app.plugins.extensions.resolve("startup-screen")?.provider.id ?? "alisio.default",
+                conflicts: app.plugins.extensions.conflicts(),
+            },
+            commands: [...app.plugins.commandInfo.entries()]
+                .filter(([, info]) => !info.builtin)
+                .map(([name]) => name),
+            builtin: [...app.plugins.builtins],
+        }, null, 2));
+    }
+    finally {
+        await app.close();
+    }
+});
+const mcp = program.command("mcp");
+mcp.command("list").action(async (_opts, cmd) => {
+    const { loadConfig } = await import("@alisio/core");
+    const o = options(cmd);
+    const config = await loadConfig(o.cwd ?? process.cwd(), {
+        file: o.config,
+        trustProject: o.trustProject,
+    });
+    console.log(JSON.stringify(Object.keys(config.mcp.servers), null, 2));
+});
+mcp
+    .command("doctor")
+    .argument("<server>")
+    .action(async (server, _opts, cmd) => {
+    const o = options(cmd);
+    if (!o.allowMcp)
+        throw new Error("Use --allow-mcp to start or connect to a configured server");
+    const { createApplication } = await import("@alisio/core");
+    const app = await createApplication({
+        ...(await cliDefaults()),
+        ...o,
+        provider: {
+            id: "inspection",
+            model: "none",
+            stream() {
+                throw new Error("Inspection only");
+            },
+        },
+    });
+    try {
+        console.log(JSON.stringify(await app.mcp.connect(server, AbortSignal.timeout(15000)), null, 2));
+    }
+    finally {
+        await app.close();
+    }
+});
+try {
+    await program.parseAsync();
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+}

package/dist/prompts/index.d.ts

@@ -0,0 +1,5 @@
+/** Prompt templates shipped with the CLI (lowest precedence; users and projects can override). */
+export declare const BUILTIN_PROMPTS: {
+    name: string;
+    text: string;
+}[];

package/dist/prompts/index.js

@@ -0,0 +1,3 @@
+import { INIT_TEMPLATE } from "./init.js";
+/** Prompt templates shipped with the CLI (lowest precedence; users and projects can override). */
+export const BUILTIN_PROMPTS = [{ name: "init", text: INIT_TEMPLATE }];

package/dist/prompts/init.d.ts

@@ -0,0 +1,2 @@
+/** Built-in `/init` prompt template (embedded so it ships in dist and in the binary). */
+export declare const INIT_TEMPLATE = "---\ndescription: Analyze this repository and create or update the root AGENTS.md\nargument-hint: \"[focus]\"\nrequires: [write]\n---\nAnalyze this repository and create or update the root `AGENTS.md`: concise, project-specific\ninstructions for coding agents working here.\n\n## 1. Explore efficiently (read-only first)\n- `list_files` on the root and key directories (use `limit`; skip vendored or generated folders).\n- `git_status` to see the state of the tree.\n- `read_file` the manifests that exist: package.json, pnpm-workspace.yaml, pyproject.toml,\n  setup.cfg, requirements*.txt, go.mod, Cargo.toml, pom.xml, build.gradle*, Gemfile, composer.json,\n  Makefile, justfile, Dockerfile. Nested workspace manifests matter in monorepos.\n- Identify the package manager from lockfiles (pnpm-lock.yaml, package-lock.json, yarn.lock,\n  bun.lock/bun.lockb, poetry.lock, uv.lock, Cargo.lock, go.sum).\n- Read build/test/lint/format/typecheck configuration (tsconfig*.json, biome.json, .eslintrc*,\n  .prettierrc*, vitest/jest/pytest config, ruff/flake8, rustfmt, golangci) and CI workflows.\n  `list_files` hides dotfiles, so probe likely paths such as `.github/workflows/ci.yml` with\n  `read_file` (a missing file just returns an error). Use `search_text` only on paths that exist.\n- Read README and CONTRIBUTING, and existing agent instruction files if present: AGENTS.md\n  (root and nested), CLAUDE.md, GEMINI.md, .cursorrules, .cursor/rules/*,\n  .github/copilot-instructions.md. Probe them with `read_file`; a missing file is not an error.\n- Sample a few representative source and test files to learn the layout and conventions. Use\n  `search_text` instead of reading many files.\n\n## 2. Write AGENTS.md (roughly 150 lines or fewer)\nCover, only where the repository gives evidence:\n- Project overview: what it is, main languages and frameworks.\n- Commands: exact setup, build, test, single-test, lint, format and typecheck commands as\n  defined in manifests or CI (for example `pnpm test`, not \"run the tests\").\n- Architecture: module or package layout with the important paths.\n- Code style and conventions actually enforced by configuration (formatter, linter rules,\n  compiler strictness, import style).\n- Testing approach: framework, where tests live, how fixtures work.\n- Gotchas and constraints: security rules, generated files, files or directories not to touch,\n  required tool versions.\n\nRules:\n- Only facts verified from files you read. No generic advice (\"write clean code\"), no invented\n  commands or paths. If something important is unknown, say so briefly instead of guessing.\n- Never include secrets, tokens or environment variable values; do not read .env files.\n- Merge useful rules from other agent instruction files and cite the source file, e.g.\n  \"(from CLAUDE.md)\".\n\n## 3. Create or update safely\n- If `AGENTS.md` does not exist, create it with `write_file` (`expectedHash: null`).\n- If it exists, `read_file` it first and update it in place: preserve human-written content and\n  intent, merge improvements, and keep edits minimal using `edit_file` with the sha256 from\n  `read_file` as `expectedHash`. Never blindly overwrite an existing AGENTS.md.\n\n## 4. Finish\nReply with a short summary of what you wrote or changed and anything you could not verify.\n\nAdditional focus from the user (may be empty): $ARGUMENTS\n";

package/dist/prompts/init.js

@@ -0,0 +1,57 @@
+/** Built-in `/init` prompt template (embedded so it ships in dist and in the binary). */
+export const INIT_TEMPLATE = `---
+description: Analyze this repository and create or update the root AGENTS.md
+argument-hint: "[focus]"
+requires: [write]
+---
+Analyze this repository and create or update the root \`AGENTS.md\`: concise, project-specific
+instructions for coding agents working here.
+
+## 1. Explore efficiently (read-only first)
+- \`list_files\` on the root and key directories (use \`limit\`; skip vendored or generated folders).
+- \`git_status\` to see the state of the tree.
+- \`read_file\` the manifests that exist: package.json, pnpm-workspace.yaml, pyproject.toml,
+  setup.cfg, requirements*.txt, go.mod, Cargo.toml, pom.xml, build.gradle*, Gemfile, composer.json,
+  Makefile, justfile, Dockerfile. Nested workspace manifests matter in monorepos.
+- Identify the package manager from lockfiles (pnpm-lock.yaml, package-lock.json, yarn.lock,
+  bun.lock/bun.lockb, poetry.lock, uv.lock, Cargo.lock, go.sum).
+- Read build/test/lint/format/typecheck configuration (tsconfig*.json, biome.json, .eslintrc*,
+  .prettierrc*, vitest/jest/pytest config, ruff/flake8, rustfmt, golangci) and CI workflows.
+  \`list_files\` hides dotfiles, so probe likely paths such as \`.github/workflows/ci.yml\` with
+  \`read_file\` (a missing file just returns an error). Use \`search_text\` only on paths that exist.
+- Read README and CONTRIBUTING, and existing agent instruction files if present: AGENTS.md
+  (root and nested), CLAUDE.md, GEMINI.md, .cursorrules, .cursor/rules/*,
+  .github/copilot-instructions.md. Probe them with \`read_file\`; a missing file is not an error.
+- Sample a few representative source and test files to learn the layout and conventions. Use
+  \`search_text\` instead of reading many files.
+
+## 2. Write AGENTS.md (roughly 150 lines or fewer)
+Cover, only where the repository gives evidence:
+- Project overview: what it is, main languages and frameworks.
+- Commands: exact setup, build, test, single-test, lint, format and typecheck commands as
+  defined in manifests or CI (for example \`pnpm test\`, not "run the tests").
+- Architecture: module or package layout with the important paths.
+- Code style and conventions actually enforced by configuration (formatter, linter rules,
+  compiler strictness, import style).
+- Testing approach: framework, where tests live, how fixtures work.
+- Gotchas and constraints: security rules, generated files, files or directories not to touch,
+  required tool versions.
+
+Rules:
+- Only facts verified from files you read. No generic advice ("write clean code"), no invented
+  commands or paths. If something important is unknown, say so briefly instead of guessing.
+- Never include secrets, tokens or environment variable values; do not read .env files.
+- Merge useful rules from other agent instruction files and cite the source file, e.g.
+  "(from CLAUDE.md)".
+
+## 3. Create or update safely
+- If \`AGENTS.md\` does not exist, create it with \`write_file\` (\`expectedHash: null\`).
+- If it exists, \`read_file\` it first and update it in place: preserve human-written content and
+  intent, merge improvements, and keep edits minimal using \`edit_file\` with the sha256 from
+  \`read_file\` as \`expectedHash\`. Never blindly overwrite an existing AGENTS.md.
+
+## 4. Finish
+Reply with a short summary of what you wrote or changed and anything you could not verify.
+
+Additional focus from the user (may be empty): $ARGUMENTS
+`;

package/dist/tui/app.d.ts

@@ -0,0 +1,8 @@
+import type { AppOptions } from "@alisio/core";
+export interface TuiOptions extends AppOptions {
+    session?: string;
+    quiet?: boolean;
+    /** `false` with --no-banner. */
+    banner?: boolean;
+}
+export declare function runTui(options: TuiOptions): Promise<void>;