trajectories 0.1.1 → 0.1.2

package/dist/deepagents_checkpoint.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+"""Read a Python LangGraph SQLite checkpoint through LangGraph's public APIs."""
+
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import sys
+from collections.abc import Iterable, Mapping
+from pathlib import Path
+from typing import Any
+
+
+def _emit(payload: Mapping[str, Any]) -> None:
+    sys.stdout.write(json.dumps(payload, ensure_ascii=False, separators=(",", ":")))
+
+
+def _fail(code: str, message: str) -> None:
+    _emit({"ok": False, "code": code, "message": message})
+    raise SystemExit(0)
+
+
+try:
+    from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+    from langgraph.checkpoint.sqlite import SqliteSaver
+    from langgraph.graph.message import add_messages
+    from langgraph.types import Overwrite
+except (ImportError, ModuleNotFoundError) as error:
+    _fail(
+        "python_dependency_missing",
+        "Reading Deep Agents checkpoints requires Python packages "
+        "langgraph and langgraph-checkpoint-sqlite; install the "
+        "agent-trajectory[deepagents] extra in this Python environment "
+        f"(import error: {error}).",
+    )
+
+
+def _request() -> dict[str, Any]:
+    try:
+        value = json.load(sys.stdin)
+    except (OSError, json.JSONDecodeError) as error:
+        _fail("invalid_input", f"Deep Agents checkpoint request is invalid: {error}")
+    if not isinstance(value, dict):
+        _fail("invalid_input", "Deep Agents checkpoint request must be an object.")
+    return value
+
+
+def _unwrap_snapshot(value: Any) -> Any:
+    # DeltaChannel history exposes its decoded snapshot through the public
+    # `seed` contract. In current LangGraph releases that value is a namedtuple
+    # with one `value` field; avoid importing its private concrete class.
+    if (
+        isinstance(value, tuple)
+        and getattr(value, "_fields", None) == ("value",)
+        and value.__class__.__name__.endswith("DeltaSnapshot")
+    ):
+        return value.value
+    return value
+
+
+def _as_messages(value: Any) -> list[Any]:
+    value = _unwrap_snapshot(value)
+    if value is None:
+        return []
+    if isinstance(value, (list, tuple)):
+        return list(value)
+    return [value]
+
+
+def _apply_message_writes(messages: list[Any], writes: Iterable[tuple[Any, str, Any]]) -> list[Any]:
+    current = messages
+    for _task_id, channel, value in writes:
+        if channel != "messages":
+            continue
+        if isinstance(value, Overwrite):
+            current = _as_messages(value.value)
+        else:
+            current = list(add_messages(current, value))
+    return current
+
+
+def _reconstruct_messages(saver: Any, checkpoint_tuple: Any) -> list[Any]:
+    channel_values = checkpoint_tuple.checkpoint.get("channel_values") or {}
+    if not isinstance(channel_values, Mapping):
+        _fail("invalid_checkpoint_state", "Checkpoint channel_values must be a mapping.")
+
+    if "messages" in channel_values:
+        messages = _as_messages(channel_values["messages"])
+    else:
+        # This is the public LangGraph API for reconstructing a DeltaChannel:
+        # it follows only the selected checkpoint's parent chain and returns
+        # already-deserialized seed/writes in oldest-to-newest order.
+        if not hasattr(saver, "get_delta_channel_history"):
+            _fail(
+                "python_dependency_missing",
+                "This checkpoint requires a LangGraph release with "
+                "get_delta_channel_history support; upgrade the deepagents extra.",
+            )
+        histories = saver.get_delta_channel_history(
+            config=checkpoint_tuple.config,
+            channels=["messages"],
+        )
+        history = histories.get("messages", {})
+        messages = _as_messages(history.get("seed"))
+        messages = _apply_message_writes(messages, history.get("writes", ()))
+
+    return _apply_message_writes(messages, checkpoint_tuple.pending_writes or ())
+
+
+def _content_parts(content: Any) -> tuple[str, list[str]]:
+    if isinstance(content, str):
+        return content, []
+    if not isinstance(content, (list, tuple)):
+        return _stringify(content), []
+
+    text: list[str] = []
+    reasoning: list[str] = []
+    for block in content:
+        if isinstance(block, str):
+            text.append(block)
+            continue
+        if not isinstance(block, Mapping):
+            continue
+        block_type = block.get("type")
+        if block_type == "reasoning":
+            value = block.get("reasoning", block.get("text"))
+            if isinstance(value, str) and value:
+                reasoning.append(value)
+        elif block_type in {"text", "input_text", "output_text"} or (
+            block_type is None and "text" in block
+        ):
+            value = block.get("text")
+            if isinstance(value, str) and value:
+                text.append(value)
+    return "\n".join(text), reasoning
+
+
+def _stringify(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    try:
+        return json.dumps(value, ensure_ascii=False, default=str, separators=(",", ":"))
+    except (TypeError, ValueError):
+        return str(value)
+
+
+def _json_safe(value: Any) -> Any:
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, Mapping):
+        return {str(key): _json_safe(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json_safe(item) for item in value]
+    return str(value)
+
+
+def _timestamp(message: Any) -> str | None:
+    for container in (
+        getattr(message, "additional_kwargs", None),
+        getattr(message, "response_metadata", None),
+    ):
+        if not isinstance(container, Mapping):
+            continue
+        for key in ("timestamp", "created_at", "createdAt"):
+            value = container.get(key)
+            if isinstance(value, str) and value:
+                return value
+    return None
+
+
+def _model(message: Any) -> str | None:
+    for container in (
+        getattr(message, "response_metadata", None),
+        getattr(message, "additional_kwargs", None),
+    ):
+        if not isinstance(container, Mapping):
+            continue
+        for key in ("model_name", "model", "model_id"):
+            value = container.get(key)
+            if isinstance(value, str) and value:
+                return value
+    return None
+
+
+def _reasoning_from_metadata(message: Any) -> list[str]:
+    output: list[str] = []
+    for container in (
+        getattr(message, "additional_kwargs", None),
+        getattr(message, "response_metadata", None),
+    ):
+        if not isinstance(container, Mapping):
+            continue
+        for key in ("reasoning", "reasoning_content"):
+            value = container.get(key)
+            if isinstance(value, str) and value and value not in output:
+                output.append(value)
+    return output
+
+
+def _message_data(message: Any) -> dict[str, Any] | None:
+    timestamp = _timestamp(message)
+    if isinstance(message, HumanMessage) or getattr(message, "type", None) == "human":
+        content, _ = _content_parts(message.content)
+        return {
+            "role": "human",
+            "content": content,
+            **({"timestamp": timestamp} if timestamp else {}),
+        }
+
+    if isinstance(message, AIMessage) or getattr(message, "type", None) == "ai":
+        content, reasoning = _content_parts(message.content)
+        reasoning.extend(
+            value for value in _reasoning_from_metadata(message) if value not in reasoning
+        )
+        calls: list[dict[str, Any]] = []
+        for call in getattr(message, "tool_calls", None) or ():
+            if not isinstance(call, Mapping):
+                continue
+            calls.append(
+                {
+                    "args": _json_safe(call.get("args", {})),
+                    **({"id": call["id"]} if isinstance(call.get("id"), str) else {}),
+                    **(
+                        {"name": call["name"]}
+                        if isinstance(call.get("name"), str)
+                        else {}
+                    ),
+                }
+            )
+        model = _model(message)
+        return {
+            "role": "ai",
+            "content": content,
+            "reasoning": reasoning,
+            "toolCalls": calls,
+            **({"model": model} if model else {}),
+            **({"timestamp": timestamp} if timestamp else {}),
+        }
+
+    if isinstance(message, ToolMessage) or getattr(message, "type", None) == "tool":
+        content, _ = _content_parts(message.content)
+        call_id = getattr(message, "tool_call_id", None)
+        if not isinstance(call_id, str):
+            call_id = ""
+        return {
+            "role": "tool",
+            "content": content,
+            "toolCallId": call_id,
+            **({"timestamp": timestamp} if timestamp else {}),
+        }
+    return None
+
+
+def _context_string(
+    channel_values: Mapping[str, Any], metadata: Mapping[str, Any], keys: tuple[str, ...]
+) -> str | None:
+    for container in (channel_values, metadata):
+        for key in keys:
+            value = container.get(key)
+            if isinstance(value, str) and value:
+                return value
+    return None
+
+
+def main() -> None:
+    request = _request()
+    path_value = request.get("path")
+    thread_id = request.get("threadId")
+    namespace = request.get("checkpointNamespace", "")
+    checkpoint_id = request.get("checkpointId")
+    if not isinstance(path_value, str) or not path_value:
+        _fail("invalid_input", "Deep Agents checkpoint path is required.")
+    if not isinstance(thread_id, str) or not thread_id:
+        _fail("invalid_input", "Deep Agents threadId is required.")
+    if not isinstance(namespace, str):
+        _fail("invalid_input", "Deep Agents checkpointNamespace must be a string.")
+    if checkpoint_id is not None and (
+        not isinstance(checkpoint_id, str) or not checkpoint_id
+    ):
+        _fail("invalid_input", "Deep Agents checkpointId must be a non-empty string.")
+
+    path = Path(path_value).expanduser()
+    if not path.is_file():
+        _fail(
+            "checkpoint_database_not_found",
+            f"Deep Agents checkpoint database does not exist: {path}",
+        )
+    if not os.access(path, os.R_OK):
+        _fail(
+            "checkpoint_database_unreadable",
+            f"Deep Agents checkpoint database is not readable: {path}",
+        )
+
+    config: dict[str, Any] = {
+        "configurable": {
+            "thread_id": thread_id,
+            "checkpoint_ns": namespace,
+            **({"checkpoint_id": checkpoint_id} if checkpoint_id else {}),
+        }
+    }
+    try:
+        with SqliteSaver.from_conn_string(str(path)) as saver:
+            checkpoint_tuple = saver.get_tuple(config)
+            if checkpoint_tuple is None:
+                label = f" checkpoint {checkpoint_id!r}" if checkpoint_id else ""
+                _fail(
+                    "checkpoint_not_found",
+                    f"No Deep Agents{label} checkpoint was found for thread "
+                    f"{thread_id!r} in namespace {namespace!r}.",
+                )
+            messages = _reconstruct_messages(saver, checkpoint_tuple)
+    except sqlite3.DatabaseError as error:
+        _fail("checkpoint_database_unreadable", f"Could not read checkpoint database: {error}")
+    except (OSError, ValueError, TypeError, KeyError) as error:
+        _fail("checkpoint_read_failed", f"Could not reconstruct Deep Agents checkpoint: {error}")
+
+    serialized_messages = [
+        data for message in messages if (data := _message_data(message)) is not None
+    ]
+    if not serialized_messages:
+        _fail(
+            "checkpoint_messages_missing",
+            "Deep Agents checkpoint did not contain canonical LangChain messages.",
+        )
+
+    channel_values = checkpoint_tuple.checkpoint.get("channel_values") or {}
+    metadata = checkpoint_tuple.metadata or {}
+    selected = checkpoint_tuple.config.get("configurable", {})
+    cwd = _context_string(
+        channel_values,
+        metadata,
+        ("cwd", "working_directory", "current_working_directory"),
+    )
+    model = _context_string(channel_values, metadata, ("model", "model_name", "model_id"))
+    if model is None:
+        model = next(
+            (
+                item["model"]
+                for item in serialized_messages
+                if item.get("role") == "ai" and isinstance(item.get("model"), str)
+            ),
+            None,
+        )
+
+    _emit(
+        {
+            "ok": True,
+            "data": {
+                "checkpointId": str(selected.get("checkpoint_id", checkpoint_tuple.checkpoint["id"])),
+                "checkpointNamespace": str(selected.get("checkpoint_ns", namespace)),
+                "checkpointTimestamp": str(checkpoint_tuple.checkpoint["ts"]),
+                "messages": serialized_messages,
+                **({"cwd": cwd} if cwd else {}),
+                **({"model": model} if model else {}),
+            },
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

package/legacy/src/cli.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import manifest from "../../package.json";
 import { SessionNotFoundError, StoreNotInitializedError, TrajectoryDb } from "./db.js";
 import { aggregateIngestDiagnostics } from "./diagnostics.js";
 import {
@@ -28,7 +28,7 @@ import {
   WriterLeaseBusyError,
 } from "./writer-lease.js";
 
-const VERSION: string = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
+const VERSION: string = manifest.version;
 
 /** The provider a `--embedding` value names; an absent flag asks for local, a bare `--embedding` asks for Gemini. */
 function requestedEmbedding(value: string | boolean | undefined): string {

package/legacy/src/sync.ts

@@ -630,12 +630,26 @@ function retryAt(now: Date, attempts: number): string {
   return new Date(now.getTime() + delayMs).toISOString();
 }
 
+declare const TRAJECTORIES_STANDALONE: boolean;
+declare const TRAJECTORIES_BUNDLED_CLI: boolean;
+
+function syncEntry(command: string): string[] {
+  // Compiled distributions execute the same private verbs in a fresh process.
+  if (typeof TRAJECTORIES_STANDALONE !== "undefined" && TRAJECTORIES_STANDALONE) {
+    return [process.execPath, command];
+  }
+  if (typeof TRAJECTORIES_BUNDLED_CLI !== "undefined" && TRAJECTORIES_BUNDLED_CLI) {
+    return [process.execPath, process.argv[1]!, command];
+  }
+  return [process.execPath, fileURLToPath(new URL("../bin/ledger-core.ts", import.meta.url)), command];
+}
+
 function workerEntry(): string[] {
-  return [process.execPath, fileURLToPath(new URL("../bin/ledger-core.ts", import.meta.url)), "__sync-worker"];
+  return syncEntry("__sync-worker");
 }
 
 function maintenanceEntry(): string[] {
-  return [process.execPath, fileURLToPath(new URL("../bin/ledger-core.ts", import.meta.url)), "__sync-maintenance"];
+  return syncEntry("__sync-maintenance");
 }
 
 export function workerReservation(
@@ -863,7 +877,7 @@ async function prepareInChild(options: SyncOptions, scanLimit: number, maxRecord
   if (remaining <= 0) throw new SyncPreparationError("timed_out");
   const result = await spawnJsonChild<SyncPreparationReply | PreparationFailure>({ protocol_version: SYNC_PROTOCOL_VERSION,
     db_path: options.dbPath, sources: options.sources, roots: options.roots, scan_limit: scanLimit, max_record_bytes: maxRecordBytes },
-    remaining, options.preparationCommand ?? [process.execPath, fileURLToPath(new URL("../bin/ledger-core.ts", import.meta.url)), "__sync-prepare"],
+    remaining, options.preparationCommand ?? syncEntry("__sync-prepare"),
     parsePreparationReply, { label: "sync_preparation" });
   if (result.status !== "ok" || !result.reply) throw new SyncPreparationError(result.status);
   if (result.reply.type === "sync_preparation_error") {

package/ops/README.md

@@ -7,10 +7,40 @@ session/log store, which requires an explicit `index --store` command.
 
 ## Install the CLI
 
+### Native CLI
+
+Native releases require no Bun, Node or npm. The repository is currently private,
+so GitHub downloads require an authenticated `gh` client with repository access.
+On an Apple Silicon Mac:
+
+```sh
+gh release download 'trajectories@0.1.2' --repo archeism/oh-my-ai \
+  --pattern 'trajectories-0.1.2-darwin-arm64.tar.gz*'
+shasum -a 256 --check trajectories-0.1.2-darwin-arm64.tar.gz.sha256
+mkdir -p "$HOME/.local/share/trajectories/native"
+tar -xzf trajectories-0.1.2-darwin-arm64.tar.gz -C "$HOME/.local/share/trajectories/native"
+bash "$HOME/.local/share/trajectories/native/trajectories-0.1.2-darwin-arm64/install.sh"
+trajectories --version
+```
+
+On Linux, choose `linux-x64` or `linux-arm64`, and use `sha256sum --check`.
+The installer refuses existing commands unless `--force` explicitly authorizes
+replacement. It creates a symlink to the retained release directory; do not
+delete that directory or separate the executable from `lib/`. It does not change
+the search database or enable an indexing service. Ensure `~/.local/bin` is on PATH.
+Local ONNX inference requires glibc 2.28+ on Linux or macOS 14+ on Apple Silicon. Deep Agents SQLite conversion
+still uses the harness's own Python/LangGraph environment.
+
+The service installers below are for source/npm installations and invoke Bun.
+For a native service, its command is the installed `trajectories sync` executable
+directly; the CLI's bounded sync and scheduler protocol are unchanged.
+
+### npm or source CLI
+
 For the npm distribution, use Bun 1.4.2 or newer:
 
 ```sh
-bun add --global trajectories@0.1.0
+bun add --global trajectories@0.1.2
 trajectories --version
 trajectories status --robot
 ```

package/ops/install-native.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# Run from an extracted native release kept in a permanent directory.
+set -euo pipefail
+RELEASE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+BIN_DIR="${TRAJECTORIES_BIN_DIR:-$HOME/.local/bin}"
+FORCE=0
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --bin-dir) [[ $# -ge 2 && -n "$2" ]] || { echo '--bin-dir requires a directory.' >&2; exit 1; }; BIN_DIR="$2"; shift 2 ;;
+    --force) FORCE=1; shift ;;
+    --help|-h) echo 'Usage: install.sh [--bin-dir DIR] [--force]'; exit 0 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+[[ -x "$RELEASE_DIR/trajectories" && -d "$RELEASE_DIR/lib" ]] || {
+  echo 'Keep install.sh, the trajectories executable, and lib/ together in the extracted release.' >&2; exit 1;
+}
+"$RELEASE_DIR/trajectories" --version
+mkdir -p "$BIN_DIR"
+TARGET="$BIN_DIR/trajectories"
+if [[ -e "$TARGET" || -L "$TARGET" ]]; then
+  if [[ -L "$TARGET" && "$(readlink "$TARGET")" == "$RELEASE_DIR/trajectories" ]]; then
+    echo "Already installed: $TARGET"; exit 0
+  fi
+  [[ "$FORCE" == 1 && ! -d "$TARGET" ]] || {
+    echo "Refusing to overwrite $TARGET; use --force for an explicit cutover." >&2; exit 1;
+  }
+fi
+STAGE="$(mktemp -d "$BIN_DIR/.trajectories-install.XXXXXX")"
+trap 'rm -rf "$STAGE"' EXIT
+ln -s "$RELEASE_DIR/trajectories" "$STAGE/trajectories"
+mv -f "$STAGE/trajectories" "$TARGET"
+echo "Installed: $TARGET"
+echo "Keep the release directory: $RELEASE_DIR"
+case ":$PATH:" in *":$BIN_DIR:"*) ;; *) echo "Add $BIN_DIR to PATH." ;; esac

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trajectories",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Portable coding-agent sessions: read, search, convert, and continue across harnesses.",
   "type": "module",
   "license": "Apache-2.0",
@@ -9,10 +9,12 @@
   "bin": { "trajectories": "./dist/cli.js" },
   "files": ["dist", "docs", "legacy/src", "legacy/bin", "legacy/scripts", "legacy/NOTICE.md", "ops", "skills", "README.md", "CHANGELOG.md", "LICENSE"],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && bun build src/index.ts --target node --format esm --outfile dist/index.js && bun build src/normalization-runtime.ts --target bun --format esm --outfile dist/normalization-runtime.js && bun build src/cli.ts --target bun --format esm --outfile dist/cli.js && bun -e \"require('node:fs').chmodSync('dist/cli.js', 0o755)\"",
+    "build": "tsc -p tsconfig.build.json && bun build src/index.ts --target node --format esm --outfile dist/index.js && bun build src/normalization-runtime.ts --target bun --format esm --outfile dist/normalization-runtime.js && bun build src/cli.ts --target bun --format esm --external onnxruntime-node --define TRAJECTORIES_BUNDLED_CLI=true --outfile dist/cli.js && bun scripts/build-assets.ts",
+    "build:native": "bun run build && bun scripts/build-native.ts",
     "test": "bun test ./test/*.test.ts",
     "verify": "bun run build && tsc -p tsconfig.legacy.json && bun run test && bun test ./legacy/tests",
-    "test:package": "bun run build && bun test ./smoke/package.test.ts"
+    "test:native": "bun scripts/check-native.ts",
+    "test:package": "bun run build && bun test ./smoke/package.test.ts && bun run test:native"
   },
   "dependencies": { "@letta-ai/trajectory": "0.4.3" },
   "optionalDependencies": { "onnxruntime-node": "^1.29.0" },

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-export {};