@orangeworks/orangetree 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# @orangeworks/orangetree
+
+## 0.4.0
+
+### Minor Changes
+
+- fa6c7d9: Add one-click bug reporting and copy-to-clipboard. Copy any assistant message or the report-form body to the clipboard, and file a bug report (with optional image attachments) from the toolbar during an online session — the report is forwarded to the cloud and filed as a GitHub issue. The report button appears only in an online session signed in through the cloud.
+- 780ab82: Add cloud-fronted remote sign-in for remote mode: open your home PC from the dashboard via a one-time magic link, and every request is gated by your cloud session. Opening the app's address directly without a session is now bounced to a "open from the dashboard" page instead of being allowed in — closing a gap where loading the page could grant access.
+- 73e5ce2: Connect a PC to the cloud directly from the app: click "Connect", approve on your phone or in your browser, and it pairs automatically — no environment variables and no onboarding-token copy-paste. The remote-access tunnel component is now downloaded on demand, and your setup is remembered between launches. A new Connection settings panel lets you choose your work folder and adjust remote options from the app instead of editing environment variables.
+
+### Patch Changes
+
+- be0a76b: Fix the subscription usage indicator failing to load. The 5-hour and weekly rate-limit usage now refreshes correctly instead of silently failing on every check.
+- 8e153c7: Remote sign-in sessions can now be ended immediately: signing out (or revoking access from the cloud) drops the remote session right away instead of after a delay, borrowed-PC sessions expire automatically a couple of hours after last use, and there is a sign-out action for a remote session. Signing out one session no longer disturbs your other active sessions.
+- 23d55cf: Fix the interface showing the wrong language on startup. When the response language was set to English (or Japanese) but the browser's own language differed, the app could boot with an English selector yet a Korean interface — including the chat's "start a conversation" placeholder. The interface language now follows the selected language on startup, and the empty chat view updates when you switch languages.
+
+## 0.3.0
+
+### Minor Changes
+
+- e557f20: Add explorer search and a per-node related-documents view. The explorer now has a search box that live-filters both files (by name/path) and nodes (by title, decision, or purpose) — click a result to open the file or jump to the node. Right-clicking a node offers "Related docs", a popover listing that node's documents (its artifact, the docs it touched, and a parent's done children's docs) that open straight in the viewer.
+- d7d25ad: Add UI multilingual support (Korean / English / Japanese). The single language selector now switches both the model's response language and the interface itself — buttons, menus, the explorer, chat, and dialogs — backed by a built-in locale catalog (no external dependency). Your choice is remembered and applied instantly on load, and `auto` follows the browser's language.
+
+### Patch Changes
+
+- 962df32: Make saving more reliable on Windows. Project state is written atomically (write-then-rename), and on Windows that rename can momentarily fail when antivirus or another reader briefly holds the file — which could drop a save. The rename now retries with a short backoff, so a transient lock no longer loses your work.
+
+## 0.2.0
+
+### Minor Changes
+
+- 5c7883a: Surface overlapping code changes between nodes. A node now records which files it edits, and when another node touches one of those files the affected node gets a "▶ 지금 반영" card plus a canvas badge, and its next turn folds the change in once (no loss, no extra cost) — so parallel work no longer silently conflicts or duplicates.
+- f0b3837: Add soft file locks for shared (non-worktree) folders. While a node edits a file in a shared folder it holds a turn-lifetime lock, shown as a 🔒 with the holder's id in the explorer; you can click to release it. This surfaces who's touching what without blocking — worktree nodes are already isolated, so they don't take locks.
+- c537427: Round out cross-node code awareness. Editing a file another node is editing at the same moment now surfaces a soft "concurrent edit" note in the next turn (read the other node to align), and every node sees an ambient digest of other nodes' recent edits — so even work that doesn't directly overlap stays visible without manual checking.
+- b033efb: Add result return-flow for detour branches. When you fork a child with "return result to parent", completing that child surfaces a "▶ 이어받아 진행" card in the parent and folds the child's decision into the parent's next turn (once), so a quick side-question rejoins the original line of work without losing context.
+- 6878f8e: Add isolated git worktrees for parallel branches. Forking with "격리" runs the child in its own git worktree and branch, so siblings editing the same files never clobber each other. Completing the node auto-commits its work and merges the branch back with --no-ff, then cleans up the worktree; on a merge conflict it aborts cleanly, preserves the worktree, and drops the node to review with a ⚠ badge. Orphaned worktrees are reconciled on startup.
+- e75bf3e: Add the branching session tree. Work is a canvas of Claude conversations where any answer can be forked into a child node; each node streams live with collapsible tool and thinking detail, supports file attachments and slash commands, and moves through a clear lifecycle (in progress, blocked, handoff, review, done) with manual completion.
+- e75bf3e: Add project workspaces, settings, and theming. Group work into projects with their own folders (read-only or read-write), per-project instructions, and context files; create, switch, and configure projects from the explorer and link node artifacts to files; view the base guidelines and open a node's linked document; and switch between light, dark, and system themes.
+- 4b89756: Nodes in the same tree now see each other's recorded decisions directly in their working context, and a new read_decisions tool pulls the fuller decision history (outputs, touched files) on demand without bloating every turn. Branch seeds are also more reliably preserved and refreshed across a child node's first turn.
+
+### Patch Changes
+
+- c7e8b15: Refine cross-node context sharing to follow the graph. A node's turns now see decisions from its ancestors and its explicit dependencies (with an on-demand tool to pull the rest), instead of a flat list of every node in the tree — keeping shared context focused and its cost flat as a project grows.
+- bbfe04d: Fix live Claude turns failing to start on Windows. The CLI is now detected as its native executable instead of an unlaunchable npm shim, so chatting with a node works out of the box.

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2026 Orangeworks (orangeworks.kr)
+
+All rights reserved.
+
+NOTE: This is a placeholder license. The canonical license terms are pending the
+commercial-restriction decision tracked in otree-docs (920-distribution OPEN-1).
+Until that decision is finalized, no license to use, copy, modify, or distribute
+this software is granted. Do not redistribute.

package/README.md

@@ -0,0 +1,55 @@
+# Orange Tree (`@orangeworks/orangetree`)
+
+Branching session-tree work-tracking tool. Local-first desktop app: break work into a DAG of nodes,
+run each node as an isolated Claude session, sync results graph-locally, and track progress on a canvas.
+
+Runs on the user's PC against their own `claude` CLI (zero inference cost). The reference implementation
+is the JS-based `orange-tree`; this repo is the all-TypeScript rebuild (canonical: `otree-docs/docs`).
+
+> Status: **0.2.0** — core feature set in place. A draggable canvas of branching Claude sessions
+> (fork, lifecycle, live streaming); projects with read-only/read-write folders, per-project
+> instructions and context files; a document explorer + viewer; light/dark/system theming; and the
+> 120-COLLAB collaboration engine — graph-local context sync, result return-flow, code-change
+> propagation, and isolated git worktrees with auto-merge + AI conflict resolution.
+> Design canon lives in `otree-docs/docs/20-design`.
+
+## Requirements
+
+- Node.js >= 20
+- A working `claude` CLI on `PATH` (or set `OTREE_CLAUDE_BIN`)
+
+## Develop
+
+```sh
+pnpm install
+git config core.hooksPath .githooks   # enable the commit gate (integrity + tsc --noEmit)
+
+pnpm dev        # esbuild-watch the frontend + node --watch the server
+pnpm build      # one-shot build -> dist/
+pnpm start      # run the built server (dist/server.js)
+pnpm typecheck  # tsc --noEmit (also runs in the pre-commit hook)
+```
+
+The app serves its UI on `127.0.0.1` (loopback only) and opens a browser.
+
+## Runtime state (git-excluded)
+
+All per-project runtime state lives in **app-data**, outside any repo (DES-PLATFORM-002):
+
+```
+<OTREE_DATA>/                 # default ~/.orangetree (env OTREE_DATA wins) — a DIRECTORY
+  global.json                 # project registry + projectless nodes + settings
+  scratch/                    # cwd for folderless sessions
+  projects/<projectId>/
+    tree.json                 # this project's node graph
+    decisions.md              # audit log (append-only)
+```
+
+## Environment
+
+| Var | Meaning |
+|---|---|
+| `OTREE_DATA` | app-data root directory (default `~/.orangetree`) |
+| `OTREE_CLAUDE_BIN` | explicit path to the `claude` executable |
+| `OTREE_PORT` | preferred port (default 4100, scans upward if taken) |
+| `OTREE_OPEN` | set `0` to not auto-open the browser |

package/dist/bin/orangetree.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+// bin/orangetree.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+
+// lib/config.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var CONFIG_VERSION = 1;
+var CONFIG_FILE = "config.json";
+function configPath(appDataRoot) {
+  return join(appDataRoot, CONFIG_FILE);
+}
+function defaults() {
+  return {
+    version: CONFIG_VERSION,
+    workRoot: null,
+    remoteEnabled: false,
+    cloudApiBase: null,
+    remoteAuth: "cloud",
+    port: null,
+    bindHost: null,
+    openBrowser: true,
+    pairing: { onboardingToken: null, consumedAt: null }
+  };
+}
+function asTrimmedString(v) {
+  return typeof v === "string" && v.trim() !== "" ? v.trim() : null;
+}
+function asHttpUrl(v) {
+  const s = asTrimmedString(v);
+  return s && /^https?:\/\//i.test(s) ? s.replace(/\/+$/, "") : null;
+}
+function asBool(v, fallback) {
+  return typeof v === "boolean" ? v : fallback;
+}
+function asPort(v) {
+  return typeof v === "number" && Number.isInteger(v) && v > 0 && v < 65536 ? v : null;
+}
+function normalize(raw) {
+  const d = defaults();
+  if (raw === null || typeof raw !== "object") return d;
+  const o = raw;
+  const p = o.pairing ?? {};
+  return {
+    version: typeof o.version === "number" ? o.version : CONFIG_VERSION,
+    workRoot: asTrimmedString(o.workRoot),
+    remoteEnabled: asBool(o.remoteEnabled, d.remoteEnabled),
+    cloudApiBase: asHttpUrl(o.cloudApiBase),
+    remoteAuth: o.remoteAuth === "token" ? "token" : "cloud",
+    port: asPort(o.port),
+    bindHost: asTrimmedString(o.bindHost),
+    openBrowser: asBool(o.openBrowser, d.openBrowser),
+    pairing: {
+      onboardingToken: asTrimmedString(p.onboardingToken),
+      consumedAt: typeof p.consumedAt === "number" ? p.consumedAt : null
+    }
+  };
+}
+function loadConfig(appDataRoot) {
+  const path = configPath(appDataRoot);
+  if (!existsSync(path)) return defaults();
+  try {
+    return normalize(JSON.parse(readFileSync(path, "utf8")));
+  } catch {
+    return defaults();
+  }
+}
+function applyConfigToEnv(appDataRoot) {
+  const cfg = loadConfig(appDataRoot);
+  const fill = (key, value) => {
+    if (value != null && process.env[key] === void 0) process.env[key] = value;
+  };
+  fill("OTREE_CLOUD_API", cfg.cloudApiBase);
+  if (cfg.remoteEnabled) {
+    fill("OTREE_REMOTE_AUTH", cfg.remoteAuth);
+    if (cfg.workRoot && existsSync(cfg.workRoot)) fill("OTREE_ROOT", cfg.workRoot);
+  }
+  fill("OTREE_PORT", cfg.port != null ? String(cfg.port) : null);
+  fill("OTREE_BIND", cfg.bindHost);
+  if (cfg.openBrowser === false) fill("OTREE_OPEN", "0");
+  return cfg;
+}
+
+// bin/orangetree.ts
+process.env.OTREE_DATA ??= join2(homedir(), ".orangetree");
+applyConfigToEnv(process.env.OTREE_DATA);
+await import("../server.js");

package/dist/public/api.js

@@ -0,0 +1,33 @@
+function toast(message, type = "info", ms = 3e3) {
+  let host = document.querySelector("#ui-toasts");
+  if (!host) {
+    host = document.createElement("div");
+    host.id = "ui-toasts";
+    document.body.append(host);
+  }
+  const t = document.createElement("div");
+  t.className = `ui-toast ${type}`;
+  t.textContent = message;
+  host.append(t);
+  setTimeout(() => {
+    t.classList.add("out");
+    setTimeout(() => t.remove(), 300);
+  }, ms);
+}
+const api = async (method, path, body) => {
+  const res = await fetch(`/api${path}`, {
+    method,
+    ...body !== void 0 ? { headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) } : {}
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const message = data.error ?? `${res.status} ${res.statusText}`;
+    toast(message, "error");
+    throw new Error(message);
+  }
+  return data;
+};
+export {
+  api,
+  toast
+};