tmux-ide 2.1.4 → 2.6.0

package/packages/daemon/dist/lib/authorship.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Character-range authorship tracking for plan files.
+ *
+ * Follows the @proof/core marks model: each mark tracks authorship at the
+ * character range level with quote-based re-anchoring when positions shift.
+ *
+ * @module authorship
+ */
+export type MarkKind = "authored" | "approved" | "flagged" | "comment" | "insert" | "delete" | "replace";
+export interface MarkRange {
+    from: number;
+    to: number;
+}
+export interface Mark {
+    id: string;
+    kind: MarkKind;
+    by: string;
+    at: string;
+    range: MarkRange;
+    quote: string;
+    orphaned?: boolean;
+}
+export interface MarksDocument {
+    version: number;
+    marks: Record<string, Mark>;
+}
+export interface AuthorshipStats {
+    aiPercent: number;
+    humanPercent: number;
+    totalChars: number;
+}
+export declare function generateMarkId(): string;
+export declare function normalizeQuote(text: string): string;
+/**
+ * Extract marks from a markdown file.
+ * Returns clean content (without the comment block) and parsed marks.
+ */
+export declare function extractMarks(markdown: string): {
+    content: string;
+    marks: MarksDocument | null;
+};
+/**
+ * Embed marks into a markdown file.
+ * Strips any existing marks comment and appends a new one at the end.
+ */
+export declare function embedMarks(markdown: string, doc: MarksDocument): string;
+export declare function createAuthored(by: string, range: MarkRange, quote: string): Mark;
+/**
+ * Calculate AI vs human authorship percentages from marks.
+ * Only counts 'authored' marks. Uses character range lengths.
+ */
+export declare function calculateStats(marks: Record<string, Mark>): AuthorshipStats;
+/**
+ * Re-anchor marks whose ranges may have shifted due to content edits.
+ * Uses quote text to find new positions. Marks orphaned if quote not found.
+ */
+export declare function reanchorMarks(content: string, marks: Record<string, Mark>): Record<string, Mark>;
+/**
+ * Tag the full content as authored by the given actor.
+ * Preserves existing marks and only adds a mark for uncovered ranges.
+ */
+export declare function tagContent(markdown: string, by: string): string;

package/packages/daemon/dist/lib/authorship.js

@@ -0,0 +1,209 @@
+/**
+ * Character-range authorship tracking for plan files.
+ *
+ * Follows the @proof/core marks model: each mark tracks authorship at the
+ * character range level with quote-based re-anchoring when positions shift.
+ *
+ * @module authorship
+ */
+// ============================================================================
+// Comment block format
+// ============================================================================
+const MARKS_START = "<!-- TMUX-IDE:MARKS";
+const MARKS_END = "-->";
+// ============================================================================
+// ID generation
+// ============================================================================
+let markIdCounter = 0;
+export function generateMarkId() {
+    return `m${Date.now()}_${++markIdCounter}`;
+}
+// ============================================================================
+// Quote normalization (matches @proof/core)
+// ============================================================================
+export function normalizeQuote(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+// ============================================================================
+// Extract / Embed
+// ============================================================================
+/**
+ * Extract marks from a markdown file.
+ * Returns clean content (without the comment block) and parsed marks.
+ */
+export function extractMarks(markdown) {
+    const startIdx = markdown.lastIndexOf(MARKS_START);
+    if (startIdx === -1) {
+        return { content: markdown, marks: null };
+    }
+    const endIdx = markdown.indexOf(MARKS_END, startIdx + MARKS_START.length);
+    if (endIdx === -1) {
+        return { content: markdown, marks: null };
+    }
+    const jsonStr = markdown.slice(startIdx + MARKS_START.length, endIdx).trim();
+    const content = (markdown.slice(0, startIdx) + markdown.slice(endIdx + MARKS_END.length)).trimEnd();
+    try {
+        const data = JSON.parse(jsonStr);
+        return { content, marks: data };
+    }
+    catch {
+        return { content, marks: null };
+    }
+}
+/**
+ * Embed marks into a markdown file.
+ * Strips any existing marks comment and appends a new one at the end.
+ */
+export function embedMarks(markdown, doc) {
+    const { content } = extractMarks(markdown);
+    const json = JSON.stringify(doc, null, 2);
+    return `${content}\n\n${MARKS_START}\n${json}\n${MARKS_END}\n`;
+}
+// ============================================================================
+// Mark creation helpers
+// ============================================================================
+export function createAuthored(by, range, quote) {
+    return {
+        id: generateMarkId(),
+        kind: "authored",
+        by,
+        at: new Date().toISOString(),
+        range,
+        quote: normalizeQuote(quote),
+    };
+}
+// ============================================================================
+// Stats calculation
+// ============================================================================
+/**
+ * Calculate AI vs human authorship percentages from marks.
+ * Only counts 'authored' marks. Uses character range lengths.
+ */
+export function calculateStats(marks) {
+    let aiChars = 0;
+    let humanChars = 0;
+    for (const mark of Object.values(marks)) {
+        if (mark.kind !== "authored")
+            continue;
+        if (mark.orphaned)
+            continue;
+        const chars = mark.range.to - mark.range.from;
+        if (mark.by.startsWith("ai:") || mark.by === "ai") {
+            aiChars += chars;
+        }
+        else {
+            humanChars += chars;
+        }
+    }
+    const totalChars = aiChars + humanChars;
+    if (totalChars === 0) {
+        return { aiPercent: 0, humanPercent: 0, totalChars: 0 };
+    }
+    return {
+        aiPercent: Math.round((aiChars / totalChars) * 100),
+        humanPercent: Math.round((humanChars / totalChars) * 100),
+        totalChars,
+    };
+}
+// ============================================================================
+// Re-anchoring: recover positions when content shifts
+// ============================================================================
+/**
+ * Find the position of a quote in content text.
+ * Returns { from, to } or null if not found.
+ */
+function findQuotePosition(content, quote) {
+    if (!quote)
+        return null;
+    const normalized = normalizeQuote(quote);
+    const normalizedContent = normalizeQuote(content);
+    const idx = normalizedContent.indexOf(normalized);
+    if (idx === -1)
+        return null;
+    // Map back to original content positions (approximate — whitespace may differ)
+    // Walk through original content counting normalized chars
+    let origFrom = -1;
+    let normalizedPos = 0;
+    for (let i = 0; i < content.length; i++) {
+        if (/\s/.test(content[i]) && (i === 0 || /\s/.test(content[i - 1])))
+            continue;
+        if (normalizedPos === idx && origFrom === -1)
+            origFrom = i;
+        if (normalizedPos === idx + normalized.length) {
+            return { from: origFrom, to: i };
+        }
+        normalizedPos++;
+    }
+    // Fallback: simple indexOf on original
+    const simpleIdx = content.indexOf(quote);
+    if (simpleIdx !== -1) {
+        return { from: simpleIdx, to: simpleIdx + quote.length };
+    }
+    return null;
+}
+/**
+ * Re-anchor marks whose ranges may have shifted due to content edits.
+ * Uses quote text to find new positions. Marks orphaned if quote not found.
+ */
+export function reanchorMarks(content, marks) {
+    const result = {};
+    for (const [id, mark] of Object.entries(marks)) {
+        // Check if current range still matches quote
+        const currentText = content.slice(mark.range.from, mark.range.to);
+        if (normalizeQuote(currentText) === normalizeQuote(mark.quote)) {
+            result[id] = mark;
+            continue;
+        }
+        // Try to re-anchor using quote
+        const newRange = findQuotePosition(content, mark.quote);
+        if (newRange) {
+            result[id] = { ...mark, range: newRange, orphaned: false };
+        }
+        else {
+            result[id] = { ...mark, orphaned: true };
+        }
+    }
+    return result;
+}
+// ============================================================================
+// Tagging: tag entire content as authored by a given actor
+// ============================================================================
+/**
+ * Tag the full content as authored by the given actor.
+ * Preserves existing marks and only adds a mark for uncovered ranges.
+ */
+export function tagContent(markdown, by) {
+    const { content, marks: existingDoc } = extractMarks(markdown);
+    const existingMarks = existingDoc?.marks ?? {};
+    // Re-anchor existing marks against current content
+    const anchored = Object.keys(existingMarks).length > 0 ? reanchorMarks(content, existingMarks) : {};
+    // Find uncovered character ranges
+    const covered = new Set();
+    for (const mark of Object.values(anchored)) {
+        if (mark.kind !== "authored" || mark.orphaned)
+            continue;
+        for (let i = mark.range.from; i < mark.range.to && i < content.length; i++) {
+            covered.add(i);
+        }
+    }
+    // Build marks for uncovered ranges (coalesce adjacent)
+    const newMarks = { ...anchored };
+    let rangeStart = -1;
+    for (let i = 0; i <= content.length; i++) {
+        const isCovered = covered.has(i);
+        const atEnd = i === content.length;
+        if (!isCovered && !atEnd && rangeStart === -1) {
+            rangeStart = i;
+        }
+        else if ((isCovered || atEnd) && rangeStart !== -1) {
+            const quote = content.slice(rangeStart, i);
+            if (quote.trim().length > 0) {
+                const mark = createAuthored(by, { from: rangeStart, to: i }, quote);
+                newMarks[mark.id] = mark;
+            }
+            rangeStart = -1;
+        }
+    }
+    const doc = { version: 2, marks: newMarks };
+    return embedMarks(content, doc);
+}

package/packages/daemon/dist/lib/canonical-daemon.d.ts

@@ -0,0 +1,21 @@
+export interface CanonicalDaemonInfo {
+    readonly pid: number;
+    readonly port: number;
+    readonly version: string;
+    readonly startedAt: string;
+    readonly bindHostname: string;
+    readonly authToken: string | null;
+}
+export declare function getCanonicalDaemonInfoPath(): string;
+export declare function writeCanonicalDaemonInfo(info: CanonicalDaemonInfo): void;
+export declare function readCanonicalDaemonInfo(): CanonicalDaemonInfo | null;
+export declare function clearCanonicalDaemonInfo(): void;
+/**
+ * Version-skew guard. A client (desktop app, editor extension, second
+ * CLI) attaching to the canonical daemon compiles in the daemon
+ * version it expects. If the live daemon advertises a different
+ * `version`, the wire contract may have drifted — warn loudly rather
+ * than failing silently on a mismatched action/WS schema.
+ */
+export declare function warnOnDaemonVersionSkew(info: CanonicalDaemonInfo, expectedVersion: string): void;
+export declare function isCanonicalDaemonAlive(info: CanonicalDaemonInfo): Promise<boolean>;

package/packages/daemon/dist/lib/canonical-daemon.js

@@ -0,0 +1,111 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const DAEMON_INFO_DIR_ENV = "TMUX_IDE_DAEMON_INFO_DIR";
+const REGISTRY_DIR_ENV = "TMUX_IDE_REGISTRY_DIR";
+const DAEMON_INFO_FILE = "daemon.json";
+export function getCanonicalDaemonInfoPath() {
+    const dir = process.env[DAEMON_INFO_DIR_ENV] ??
+        process.env[REGISTRY_DIR_ENV] ??
+        join(homedir(), ".tmux-ide");
+    return join(dir, DAEMON_INFO_FILE);
+}
+function parseCanonicalDaemonInfo(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const info = raw;
+    const pid = info.pid;
+    const port = info.port;
+    if (typeof pid !== "number" || typeof port !== "number")
+        return null;
+    if (!Number.isInteger(pid) || !Number.isInteger(port))
+        return null;
+    if (typeof info.version !== "string" || typeof info.startedAt !== "string")
+        return null;
+    if (typeof info.bindHostname !== "string")
+        return null;
+    if (info.authToken !== null && typeof info.authToken !== "string")
+        return null;
+    return {
+        pid,
+        port,
+        version: info.version,
+        startedAt: info.startedAt,
+        bindHostname: info.bindHostname,
+        authToken: info.authToken,
+    };
+}
+export function writeCanonicalDaemonInfo(info) {
+    const path = getCanonicalDaemonInfoPath();
+    mkdirSync(dirname(path), { recursive: true });
+    const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    const persisted = {
+        pid: info.pid,
+        port: info.port,
+        version: info.version,
+        startedAt: info.startedAt,
+        bindHostname: info.bindHostname,
+        authToken: info.authToken,
+    };
+    writeFileSync(tmpPath, JSON.stringify(persisted, null, 2) + "\n", "utf-8");
+    renameSync(tmpPath, path);
+}
+export function readCanonicalDaemonInfo() {
+    const path = getCanonicalDaemonInfoPath();
+    if (!existsSync(path))
+        return null;
+    try {
+        return parseCanonicalDaemonInfo(JSON.parse(readFileSync(path, "utf-8")));
+    }
+    catch {
+        return null;
+    }
+}
+export function clearCanonicalDaemonInfo() {
+    rmSync(getCanonicalDaemonInfoPath(), { force: true });
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function probeHostname(bindHostname) {
+    return bindHostname === "0.0.0.0" ? "127.0.0.1" : bindHostname;
+}
+function timeoutSignal(ms) {
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), ms).unref?.();
+    return controller.signal;
+}
+/**
+ * Version-skew guard. A client (desktop app, editor extension, second
+ * CLI) attaching to the canonical daemon compiles in the daemon
+ * version it expects. If the live daemon advertises a different
+ * `version`, the wire contract may have drifted — warn loudly rather
+ * than failing silently on a mismatched action/WS schema.
+ */
+export function warnOnDaemonVersionSkew(info, expectedVersion) {
+    if (info.version === expectedVersion)
+        return;
+    console.warn(`[tmux-ide] canonical daemon version skew: daemon.json reports ` +
+        `"${info.version}" but this client expects "${expectedVersion}". ` +
+        `The action/WS contract may have drifted — restart the canonical ` +
+        `daemon (tmux-ide) so it matches this client build.`);
+}
+export async function isCanonicalDaemonAlive(info) {
+    if (!isPidAlive(info.pid))
+        return false;
+    try {
+        const res = await fetch(`http://${probeHostname(info.bindHostname)}:${info.port}/health`, {
+            signal: timeoutSignal(750),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/packages/daemon/dist/lib/cli-action-bridge.d.ts

@@ -0,0 +1,27 @@
+import { type ActionInput, type ActionName, type ActionResult } from "../command-center/actions/contract.ts";
+import type { ActionErrorCode } from "../command-center/actions/errors.ts";
+import { type CanonicalDaemonInfo } from "./canonical-daemon.ts";
+import { type EmbeddedDaemonHandle, type EmbeddedDaemonOptions } from "./daemon-embed.ts";
+interface ActionFailure {
+    code: ActionErrorCode;
+    message: string;
+    details?: unknown;
+}
+interface CliActionBridgeDeps {
+    fetch: typeof fetch;
+    cwd: () => string;
+    readCanonicalDaemonInfo: () => CanonicalDaemonInfo | null;
+    clearCanonicalDaemonInfo: () => void;
+    isCanonicalDaemonAlive: (info: CanonicalDaemonInfo) => Promise<boolean>;
+    startEmbeddedDaemon: (opts: EmbeddedDaemonOptions) => Promise<EmbeddedDaemonHandle>;
+}
+export declare class CliActionInvocationError extends Error {
+    readonly code: ActionErrorCode;
+    readonly details: unknown;
+    constructor(error: ActionFailure);
+}
+export declare function __setCliActionBridgeDepsForTests(overrides: Partial<CliActionBridgeDeps>): () => void;
+export declare function tryDispatchAction<Name extends ActionName>(name: Name, input: ActionInput<Name>, options?: {
+    cwd?: string;
+}): Promise<ActionResult<Name> | null>;
+export {};

package/packages/daemon/dist/lib/cli-action-bridge.js

@@ -0,0 +1,161 @@
+import { createRequire } from "node:module";
+import { z } from "zod";
+import { ActionContractsZ, } from "../command-center/actions/contract.js";
+import { clearCanonicalDaemonInfo, isCanonicalDaemonAlive, readCanonicalDaemonInfo, warnOnDaemonVersionSkew, } from "./canonical-daemon.js";
+import { startEmbeddedDaemon, } from "./daemon-embed.js";
+const FailureEnvelopeZ = z.object({
+    ok: z.literal(false),
+    error: z.object({
+        code: z.string(),
+        message: z.string(),
+        details: z.unknown().optional(),
+    }),
+});
+let deps = {
+    fetch,
+    cwd: () => process.cwd(),
+    readCanonicalDaemonInfo,
+    clearCanonicalDaemonInfo,
+    isCanonicalDaemonAlive,
+    startEmbeddedDaemon,
+};
+export class CliActionInvocationError extends Error {
+    code;
+    details;
+    constructor(error) {
+        super(error.message);
+        this.name = "CliActionInvocationError";
+        this.code = error.code;
+        this.details = error.details ?? null;
+    }
+}
+export function __setCliActionBridgeDepsForTests(overrides) {
+    const previous = deps;
+    deps = { ...deps, ...overrides };
+    return () => {
+        deps = previous;
+    };
+}
+function timeoutSignal(ms) {
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), ms).unref?.();
+    return controller.signal;
+}
+async function isDaemonAlive(port) {
+    try {
+        const res = await deps.fetch(`http://127.0.0.1:${port}/health`, {
+            signal: timeoutSignal(500),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function hostnameForClient(bindHostname) {
+    return bindHostname === "0.0.0.0" ? "127.0.0.1" : bindHostname;
+}
+function daemonBaseUrl(info) {
+    return `http://${hostnameForClient(info.bindHostname)}:${info.port}`;
+}
+const requireFromHere = createRequire(import.meta.url);
+/** The daemon version this CLI client was built against — compared
+ *  against the live daemon's advertised version on attach. */
+function expectedDaemonVersion() {
+    try {
+        const pkg = requireFromHere("../../package.json");
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+async function resolveCanonicalDaemon() {
+    const existing = deps.readCanonicalDaemonInfo();
+    if (existing) {
+        if (await deps.isCanonicalDaemonAlive(existing)) {
+            warnOnDaemonVersionSkew(existing, expectedDaemonVersion());
+            return { baseUrl: daemonBaseUrl(existing), transientHandle: null, restoreCwd: null };
+        }
+        deps.clearCanonicalDaemonInfo();
+    }
+    // Test / short-lived-CLI escape: skip the transient daemon spawn when
+    // TMUX_IDE_CLI_NO_AUTOSTART is set. Callers (e.g. config-cli.test.ts)
+    // exercise the local-mutation fallback path; without this guard a
+    // single `tmux-ide config enable-team` in a fixture dir would start a
+    // full embedded daemon and never tear it down in time.
+    if (process.env.TMUX_IDE_CLI_NO_AUTOSTART) {
+        return null;
+    }
+    const dir = deps.cwd();
+    const previousCwd = process.cwd();
+    try {
+        process.chdir(dir);
+        const handle = await deps.startEmbeddedDaemon({
+            sessionName: undefined,
+            bindHostname: "127.0.0.1",
+            silent: true,
+        });
+        if (!(await isDaemonAlive(handle.port))) {
+            await handle.stop();
+            process.chdir(previousCwd);
+            return null;
+        }
+        return { baseUrl: handle.apiBaseUrl, transientHandle: handle, restoreCwd: previousCwd };
+    }
+    catch {
+        process.chdir(previousCwd);
+        return null;
+    }
+}
+async function stopTransientDaemon(daemon) {
+    if (daemon.transientHandle)
+        await daemon.transientHandle.stop().catch(() => undefined);
+    if (daemon.restoreCwd)
+        process.chdir(daemon.restoreCwd);
+}
+export async function tryDispatchAction(name, input, options = {}) {
+    const dir = options.cwd ?? deps.cwd();
+    const previousDeps = deps;
+    deps = { ...deps, cwd: () => dir };
+    const daemon = await resolveCanonicalDaemon();
+    deps = previousDeps;
+    if (!daemon)
+        return null;
+    const contract = ActionContractsZ[name];
+    const parsedInput = contract.input.parse(input);
+    let response;
+    try {
+        response = await deps.fetch(`${daemon.baseUrl}/api/v2/action/${encodeURIComponent(name)}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(parsedInput),
+            signal: timeoutSignal(2000),
+        });
+    }
+    catch {
+        await stopTransientDaemon(daemon);
+        return null;
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        await stopTransientDaemon(daemon);
+        return null;
+    }
+    await stopTransientDaemon(daemon);
+    const failure = FailureEnvelopeZ.safeParse(body);
+    if (failure.success) {
+        throw new CliActionInvocationError({
+            code: failure.data.error.code,
+            message: failure.data.error.message,
+            details: failure.data.error.details,
+        });
+    }
+    const success = z.object({ ok: z.literal(true), result: contract.result }).safeParse(body);
+    if (!success.success)
+        return null;
+    return success.data.result;
+}

package/packages/daemon/dist/lib/daemon-embed.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Programmatic tmux-ide daemon entrypoint.
+ *
+ * This is the shared runtime used by the standalone daemon process and by
+ * embedders such as Electron's main process.
+ */
+import { type ProjectActivationOptions } from "./active-projects.ts";
+export interface EmbeddedDaemonOptions {
+    sessionName?: string;
+    port?: number;
+    bindHostname?: string;
+    authToken?: string | null;
+    localBypassToken?: string | null;
+    takeoverIfRunning?: boolean;
+    silent?: boolean;
+    /** @deprecated Use bindHostname. */
+    hostname?: string;
+}
+export interface EmbeddedDaemonHandle {
+    readonly port: number;
+    readonly apiBaseUrl: string;
+    readonly wsUrl: string;
+    readonly localBypassToken: string | null;
+    activateProject(projectName: string, options?: ProjectActivationOptions): Promise<{
+        stop: () => Promise<void>;
+    }>;
+    stop(opts?: {
+        gracefulMs?: number;
+    }): Promise<void>;
+}
+export declare function startEmbeddedDaemon(opts: EmbeddedDaemonOptions): Promise<EmbeddedDaemonHandle>;