wolli 0.0.1 → 0.0.3

package/LICENSE

@@ -0,0 +1,182 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the
+copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work (an example is provided in the Appendix
+below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original
+version of the Work and any modifications or additions to that Work or
+Derivative Works thereof, that is intentionally submitted to Licensor for
+inclusion in the Work by the copyright owner or by an individual or Legal Entity
+authorized to submit on behalf of the copyright owner. For the purposes of this
+definition, "submitted" means any form of electronic, verbal, or written
+communication sent to the Licensor or its representatives, including but not
+limited to communication on electronic mailing lists, source code control
+systems, and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but excluding
+communication that is conspicuously marked or otherwise designated in writing by
+the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License,
+each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section) patent
+license to make, have made, use, offer to sell, sell, import, and otherwise
+transfer the Work, where such license applies only to those patent claims
+licensable by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s) with the Work
+to which such Contribution(s) was submitted. If You institute patent litigation
+against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Work or a Contribution incorporated within the Work
+constitutes direct or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate as of the date
+such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any part
+of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then
+any Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the Derivative
+Works; within the Source form or documentation, if provided along with the
+Derivative Works; or, within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents of the NOTICE
+file are for informational purposes only and do not modify the License. You may
+add Your own attribution notices within Derivative Works that You distribute,
+alongside or as an addendum to the NOTICE text from the Work, provided that such
+additional attribution notices cannot be construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions. Notwithstanding the above, nothing herein shall
+supersede or modify the terms of any separate license agreement you may have
+executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work (and each Contributor provides its
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied, including, without limitation, any warranties or
+conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any risks
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by
+applicable law (such as deliberate and grossly negligent acts) or agreed to in
+writing, shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any character
+arising as a result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill, work stoppage,
+computer failure or malfunction, or any and all other commercial damages or
+losses), even if such Contributor has been advised of the possibility of such
+damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations
+and/or rights consistent with this License. However, in accepting such
+obligations, You may act only on Your own behalf and on Your sole
+responsibility, not on behalf of any other Contributor, and only if You agree to
+indemnify, defend, and hold each Contributor harmless for any liability incurred
+by, or claims asserted against, such Contributor by reason of your accepting any
+such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification
+within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/README.md

@@ -1,3 +1,137 @@
-# wolli
+<div align="center">
 
-Placeholder package. Real implementation coming soon.
+# Wolli
+
+**Create purposeful, self-extending AI agents.**
+
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+[![npm](https://img.shields.io/npm/v/wolli.svg)](https://www.npmjs.com/package/wolli)
+[![CI](https://github.com/opsyhq/wolli/actions/workflows/ci.yml/badge.svg)](https://github.com/opsyhq/wolli/actions/workflows/ci.yml)
+
+[Install](#install) · [How it works](#how-it-works) · [Roadmap](ROADMAP.md)
+
+</div>
+
+---
+
+> **What is my purpose?**
+
+Wolli lets you create purposeful agents. That purpose becomes the organizing
+principle of an agent's life: it remembers across sessions, runs on a schedule,
+acts on events, and extends itself to do its job better over time, writing its
+own skills, integrations, and extensions as the work demands.
+
+## Install
+
+```sh
+npm install -g wolli
+wolli
+```
+
+The first run sets up your provider and creates your first agent. A new agent
+starts in a **forming** state: it interviews you to work out its purpose and
+records what it learns, and does not act unattended until you deploy it. Agents and
+state live under `~/.wolli`. `●` deployed and `○` forming.
+
+```
+ Agents
+
+ → ● inbox    Triage my email each morning, draft replies to the routine ones, flag what needs me.
+   ● scout    Watch the repos and deps we ship; when a release or CVE needs action, open an issue and ping me.
+   ● ledger   Track project spend across providers, reconcile invoices weekly, warn me before a budget tips over.
+   ○ sprout   Still working out my purpose.
+
+ ↑/↓ browse · enter chat · tab details · type to search commands · ctrl+c quit
+```
+
+## How it works
+
+- **Purpose-built.** You state the agent's purpose at birth. It decides what the
+  agent stores, when it speaks up, and what it does unattended.
+- **Self-extending.** The agent builds itself out for its purpose. It curates its
+  own memory and authors and installs its own skills, tools, extensions and integrations; they
+  live in its home and load on reload. The agent grows more capable at its job
+  instead of staying a fixed tool.
+- **Persistent.** Sessions are an append-only JSONL tree, the agent's lifetime
+  memory. Nothing is rewritten; context is reconstructed deterministically and the
+  latest leaf resumes by default.
+- **Curated memory.** Three files are read once and frozen into the system prompt
+  per session, and the agent maintains them through a memory tool:
+
+  | File | Holds |
+  | --- | --- |
+  | `SOUL.md` | Identity, authored at deploy. |
+  | `MEMORY.md` | Durable notes the agent keeps. |
+  | `USER.md` | Facts about its human. |
+
+- **Always on, locally.** A per-agent daemon supervised by launchd (macOS) or
+  systemd (Linux) runs the agent on schedules and events while your machine is on.
+- **Sandboxed.** The agent runs in a sandbox by default: `srt` (Apple Seatbelt /
+  bubblewrap), or optional Docker. Reaching your real machine is an explicit,
+  approval-gated escalation.
+- **Any model.** Multi-provider via OAuth `/login` (Anthropic, OpenAI, and others).
+
+## Lifecycle
+
+| State | What happens |
+| --- | --- |
+| **forming** | Interviews its human and records memory. Does not act unattended. |
+| **deployed** | The agent has authored its purpose and `SOUL.md`, and you confirmed `/deploy`, the single human-held latch. It now runs on schedules and events. |
+
+`wolli delete <name>` removes an agent and its state.
+
+## Extending an agent
+
+An agent's capabilities are plugins under its own home, so deleting the agent
+removes them with it:
+
+| Type | What it adds |
+| --- | --- |
+| **Integrations** | TypeScript modules: tools, commands, events, UI. |
+| **Extensions** | TypeScript modules: tools, commands, events, UI. |
+| **Skills** | The Agent Skills standard. |
+| **Prompt templates** | `/name` slash commands. |
+| **Themes** | TUI appearance. |
+
+Two integrations ship bundled: **Telegram** (bidirectional chat) and a
+**scheduler** (cron). Manage plugins with `wolli <agent> plugins ...`.
+
+## CLI
+
+| Command | Action |
+| --- | --- |
+| `wolli` | Set up on first run; otherwise pick an agent and open it |
+| `wolli new <name>` | Create and birth a new agent |
+| `wolli <agent>` | Open a specific agent interactively |
+| `wolli <agent> "msg" --print` | One-shot, non-interactive reply |
+| `wolli list` | List agents |
+| `wolli restart <name>` | Restart an agent's daemon |
+| `wolli delete <name>` | Remove an agent and its state |
+| `wolli <agent> plugins ...` | Manage an agent's plugins |
+
+## Documentation
+
+Full documentation is in [`packages/wolli/docs`](packages/wolli/docs/index.md):
+extensions, skills, prompt templates, themes, integrations, plugins, and the SDK.
+
+## Roadmap
+
+Cloud sync, hosted email identity, agent-to-agent messaging, durable runtimes, and
+more inbound integrations are not built yet. Shipped versus planned is tracked in
+[ROADMAP.md](ROADMAP.md).
+
+## Contributing
+
+Wolli is a pnpm + TypeScript monorepo (Node >= 22.19).
+
+```sh
+pnpm install
+pnpm build
+pnpm test
+```
+
+See [AGENTS.md](AGENTS.md) for development rules before opening a pull request.
+
+## License
+
+[Apache-2.0](LICENSE)

package/built-in/plugins/discord/README.md

@@ -0,0 +1,156 @@
+# Discord
+
+Connect a wolli agent to Discord. The bot runs over Discord's gateway WebSocket,
+gives each channel and DM its own wolli session, and replies in place. Setup is a
+few clicks in the Discord Developer Portal plus a single token prompt.
+
+## How the bot behaves
+
+Before setup, here's the part most people want to know: this bot answers
+**everything it can read**. There is no `@mention` gate.
+
+| Context | Behavior |
+|---------|----------|
+| **DMs** | Responds to every non-empty message. |
+| **Server channels** | Responds to every non-empty message in any channel it can read. No `@mention` required — unlike some Discord agents, the bot replies to plain messages. Scope where it listens with `allowedChannelIds`. |
+| **Other bots / itself** | Ignored. The bot skips its own messages and messages from any other bot, so it can't loop. |
+| **Empty / media-only messages** | Skipped (there is no inbound media handling). |
+
+While a turn runs, the bot shows Discord's **typing…** indicator in the channel and
+keeps it alive until the reply lands. Replies are chunked at **2000 characters**
+(Discord's per-message limit); Discord renders markdown natively, so formatting in
+the agent's output comes through as-is.
+
+If a new message arrives while the agent is mid-reply, it is **queued as a
+follow-up** and answered after the current turn finishes — it does not interrupt the
+in-flight response.
+
+## Session model
+
+Each channel and DM gets its **own wolli session**, bound by a `discord:channel`
+tag:
+
+- **Inbound** — an incoming message is routed to the session tagged for its channel.
+  If none exists yet, one is created and tagged on the spot. Histories never bleed
+  across channels, and two channels can run in parallel.
+- **Outbound** — the reply rides the producing session's tag, so the answer always
+  returns to the channel that started the turn — not to whoever messaged most
+  recently.
+
+## Setup
+
+### 1. Create a Discord application
+
+Open the [Discord Developer Portal](https://discord.com/developers/applications) and
+click **New Application**. Name it (e.g. "Wolli") and accept the terms.
+
+### 2. Enable the Message Content Intent
+
+This is the critical step. Open **Bot** in the sidebar, scroll to **Privileged
+Gateway Intents**, toggle **Message Content Intent** to **ON**, and **Save Changes**.
+
+Without it, the bot still receives message events but the message text arrives
+**empty**, so it can never reply. This is the single privileged intent the bot
+needs — you do **not** need Server Members or Presence.
+
+### 3. Reset and copy the bot token
+
+On the same **Bot** page, click **Reset Token**, complete 2FA if prompted, and copy
+the token. It is shown only once — if you lose it, reset and generate a new one. Keep
+it secret.
+
+### 4. Invite the bot
+
+Open **OAuth2 → URL Generator** and select:
+
+- **Scopes:** `bot`
+- **Bot Permissions:** **View Channels**, **Send Messages**, **Read Message History**
+
+Copy the generated URL at the bottom, open it, pick a server you administer, and
+authorize. Only the `bot` scope is required — the `applications.commands` scope is
+not needed.
+
+### 5. Install and onboard in wolli
+
+```bash
+wolli <agent> plugins install ./built-in/plugins/discord
+```
+
+In an interactive terminal this runs onboarding immediately: it prints the connect
+guide, then prompts you to **paste the bot token**. Paste the token from step 3.
+Wolli verifies it with a live `GET /users/@me` call and stores it. That single token
+is the only value you enter.
+
+If you installed non-interactively, onboard later with:
+
+```bash
+wolli <agent> plugins configure discord
+```
+
+### 6. Restart the agent
+
+```bash
+wolli restart <agent>
+```
+
+This starts the gateway producer that connects to Discord. After onboarding a fresh
+integration, restart the agent once so the bot comes online and begins responding.
+
+## Configuration reference
+
+Configuration lives per agent in `~/.wolli/agents/<name>/integrations.json` under
+`discord.default`:
+
+```json
+{
+  "discord": {
+    "default": {
+      "botToken": "...",
+      "allowedChannelIds": ["123456789012345678"]
+    }
+  }
+}
+```
+
+| Field | Required | Default | Purpose |
+|-------|----------|---------|---------|
+| `botToken` | Yes | — | The bot token. Onboarding stores it raw; a `$ENV` / `!cmd` reference placed here by hand also resolves on read. |
+| `allowedChannelIds` | No | *(any channel)* | Allowlist of channel IDs the bot will respond in. Empty or absent accepts **any** channel the bot can read (logged as a warning at startup). |
+
+Discord IDs are snowflakes — keep them as **quoted strings** in JSON, never numbers,
+since a 64-bit snowflake exceeds JavaScript's safe-integer range. To grab a channel
+ID, enable **Developer Mode** in Discord (Settings → Advanced), then right-click a
+channel and **Copy Channel ID**.
+
+`allowedChannelIds` is not asked during onboarding — edit `integrations.json` to set
+it.
+
+## Not supported
+
+The bot is deliberately focused on text chat. It does not provide:
+
+- Mention-gating — it answers every readable message, not only `@mentions`.
+- User, role, or guild allowlists — channel-level `allowedChannelIds` is the only
+  scope control.
+- Threads or auto-threading.
+- Reactions.
+- Native Discord slash commands.
+- Inbound or outbound media, attachments, or voice.
+
+## Troubleshooting
+
+| Symptom | Fix |
+|---------|-----|
+| Bot is online but never replies | Enable the **Message Content Intent** (step 2). Without it the message text arrives empty and there is nothing to answer. |
+| `Disallowed intents` on connect | Same cause: the Message Content Intent is not enabled in the Developer Portal. |
+| No reply right after the first install/onboard | Restart the agent (`wolli restart <agent>`) so the gateway producer starts. |
+| Silence in one specific channel | The bot is missing **View Channels** / **Send Messages** there, or the channel isn't in `allowedChannelIds`. Try a DM to isolate. |
+
+## Security
+
+- `allowedChannelIds` is the only access gate today. With it empty, **any** channel
+  the bot can read is accepted — set it to lock the bot to known channels.
+- There is no per-user or per-role gate. Anyone who can post in an allowed channel
+  can drive the agent, so keep the bot in trusted channels.
+- The bot token grants full control of the bot account — never commit it or share
+  it. Wolli writes `integrations.json` with mode `0600`.

package/built-in/plugins/discord/discord-chat.ts

@@ -0,0 +1,87 @@
+/**
+ * Discord chat extension — maps the transport's `message` events onto wolli sessions:
+ * each channel/DM gets its own session (bound by a `discord:channel` tag), inbound text
+ * is queued as a followUp, and the final assistant text is sent back on `agent_end`.
+ * Paired with `index.ts`.
+ */
+
+import type { AgentMessage } from "@opsyhq/agent";
+import type { ExtensionAPI } from "@opsyhq/wolli";
+
+// Discord's typing state lasts ~10s; refresh a little ahead of that.
+const TYPING_INTERVAL_MS = 8000;
+
+interface DiscordMessage {
+	channelId: string;
+	messageId: string;
+	text: string;
+	author: { id: string; name?: string };
+}
+
+/** Text of the last assistant message; "" for a pure tool-call turn. */
+function finalAssistantText(messages: AgentMessage[]): string {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const m = messages[i];
+		if (m.role !== "assistant") continue;
+		return m.content
+			.filter((c): c is { type: "text"; text: string } => c.type === "text")
+			.map((c) => c.text)
+			.join("")
+			.trim();
+	}
+	return "";
+}
+
+export default function (wolli: ExtensionAPI) {
+	const discord = wolli.getIntegration("discord", "default");
+
+	let typingTimer: ReturnType<typeof setInterval> | undefined;
+
+	discord.on("message", async (data) => {
+		const m = data as DiscordMessage;
+
+		// Reuse this channel's session, or create + tag a fresh one.
+		const channelTag = { "discord:channel": m.channelId };
+		const [match] = await wolli.findSessions(channelTag);
+		const session = match
+			? await wolli.openSession(match.id)
+			: await wolli.createSession({
+					setup: async (sessionManager) => {
+						await sessionManager.appendTags(channelTag);
+					},
+				});
+
+		// followUp: a message arriving mid-turn queues instead of interrupting.
+		void session.sendUserMessage(m.text, { deliverAs: "followUp" });
+	});
+
+	const stopTyping = (): void => {
+		if (typingTimer) {
+			clearInterval(typingTimer);
+			typingTimer = undefined;
+		}
+	};
+
+	wolli.on("agent_start", async (_event, ctx) => {
+		const channelId = ctx.session.getTags()["discord:channel"];
+		if (!channelId) return; // not a discord-bound session
+		const sendTyping = () => {
+			void discord.call("sendTyping", { channelId }).catch(() => {});
+		};
+		sendTyping();
+		stopTyping();
+		typingTimer = setInterval(sendTyping, TYPING_INTERVAL_MS);
+	});
+
+	wolli.on("agent_end", async ({ messages }, ctx) => {
+		stopTyping();
+
+		// Reply goes to the channel that started this turn (the producing session's tag).
+		const channelId = ctx.session.getTags()["discord:channel"];
+		if (!channelId) return; // not a discord-bound session
+
+		const text = finalAssistantText(messages as AgentMessage[]);
+		if (!text) return; // pure tool-call turn — nothing to send
+		await discord.call("sendMessage", { channelId, text });
+	});
+}