scribeclock 0.0.0-stage → 0.1.0

package/dist/mcp/schema.js

@@ -0,0 +1,242 @@
+import { usageError } from "../cli/errors.js";
+import { closest } from "../cli/parser.js";
+export function kebab(name) {
+    return name.replace(/_/g, "-");
+}
+export function snake(name) {
+    return name.replace(/-/g, "_");
+}
+export function schemaTypes(prop) {
+    if (!prop || prop.type === undefined)
+        return ["string"];
+    return Array.isArray(prop.type) ? prop.type.map(String) : [String(prop.type)];
+}
+/** Flags a tool accepts, from its inputSchema (required ones first, then alphabetical). */
+export function schemaFlags(schema) {
+    const props = schema?.properties ?? {};
+    const required = new Set(schema?.required ?? []);
+    const out = Object.entries(props).map(([name, prop]) => {
+        const types = schemaTypes(prop);
+        return {
+            name,
+            types: types.filter((t) => t !== "null"),
+            nullable: types.includes("null"),
+            description: prop.description ?? "",
+            required: required.has(name),
+            enum: prop.enum,
+            default: prop.default,
+            items: prop.items,
+        };
+    });
+    out.sort((a, b) => (a.required === b.required ? a.name.localeCompare(b.name) : a.required ? -1 : 1));
+    return out;
+}
+/**
+ * Turns `--key value`, `--key=value`, `key=value`, `--flag` / `--no-flag`, repeated flags and bare
+ * positionals into typed tool arguments according to the tool's inputSchema.
+ *
+ * Positionals fill the schema's `required` properties in order (so `get_task #12` works); extra
+ * positionals are an error. `--args '{json}'` (or `--json '{json}'`) merges a JSON object in.
+ */
+export function parseToolArgs(tokens, schema, sources = {}) {
+    const props = schema?.properties ?? {};
+    const required = schema?.required ?? [];
+    const args = {};
+    const positionals = [];
+    const resolveKey = (raw) => {
+        const k = snake(raw);
+        if (k in props)
+            return k;
+        const alt = Object.keys(props).find((p) => p.toLowerCase() === k.toLowerCase());
+        if (alt)
+            return alt;
+        if (schema?.additionalProperties === false) {
+            const near = closest(k, Object.keys(props));
+            throw usageError(`Unknown argument "${raw}" for this tool.`, near ? `Did you mean --${kebab(near)}?` : `Run with --help to see the accepted arguments.`);
+        }
+        return k;
+    };
+    const setValue = (key, raw, negated = false) => {
+        const prop = props[key];
+        const types = schemaTypes(prop);
+        const isBool = types.includes("boolean");
+        if (raw === undefined) {
+            if (!isBool)
+                throw usageError(`--${kebab(key)} needs a value.`);
+            args[key] = !negated;
+            return;
+        }
+        const expanded = expandFileRef(raw, sources);
+        const value = coerceValue(expanded, prop, key);
+        if (types.includes("array") && !Array.isArray(value)) {
+            const prev = Array.isArray(args[key]) ? args[key] : [];
+            args[key] = [...prev, value];
+        }
+        else if (types.includes("array") && Array.isArray(args[key]) && Array.isArray(value)) {
+            args[key] = [...args[key], ...value];
+        }
+        else {
+            args[key] = value;
+        }
+    };
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t === "--args" || t === "--json" || t.startsWith("--args=") || t.startsWith("--json=")) {
+            const eq = t.indexOf("=");
+            const raw = eq > 0 ? t.slice(eq + 1) : tokens[++i];
+            if (raw === undefined)
+                throw usageError(`${t} needs a JSON object.`);
+            let parsed;
+            try {
+                parsed = JSON.parse(expandFileRef(raw, sources));
+            }
+            catch {
+                throw usageError(`${t.split("=")[0]} must be a JSON object, e.g. --args '{"task_id":"#12"}'.`);
+            }
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                throw usageError(`${t.split("=")[0]} must be a JSON object.`);
+            for (const [k, v] of Object.entries(parsed))
+                args[resolveKey(k)] = v;
+            continue;
+        }
+        if (t.startsWith("--") && t.length > 2) {
+            const eq = t.indexOf("=");
+            const rawKey = (eq > 0 ? t.slice(2, eq) : t.slice(2)).trim();
+            const inline = eq > 0 ? t.slice(eq + 1) : undefined;
+            let negated = false;
+            let key;
+            if (rawKey.startsWith("no-") && !(snake(rawKey) in props) && snake(rawKey.slice(3)) in props) {
+                key = snake(rawKey.slice(3));
+                negated = true;
+            }
+            else {
+                key = resolveKey(rawKey);
+            }
+            if (negated) {
+                setValue(key, undefined, true);
+                continue;
+            }
+            if (inline !== undefined) {
+                setValue(key, inline);
+                continue;
+            }
+            const next = tokens[i + 1];
+            const isBool = schemaTypes(props[key]).includes("boolean");
+            if (next === undefined || (next.startsWith("--") && next.length > 2) || (isBool && !/^(true|false|yes|no|1|0)$/i.test(next))) {
+                setValue(key, undefined);
+            }
+            else {
+                setValue(key, next);
+                i++;
+            }
+            continue;
+        }
+        const kv = /^([A-Za-z_][A-Za-z0-9_-]*)=(.*)$/s.exec(t);
+        if (kv && !t.startsWith("#")) {
+            setValue(resolveKey(kv[1]), kv[2]);
+            continue;
+        }
+        positionals.push(t);
+    }
+    // Positionals → required properties that are still missing, in schema order.
+    const slots = required.filter((r) => !(r in args));
+    for (const p of positionals) {
+        const slot = slots.shift();
+        if (!slot) {
+            // A single optional "identifier-like" property can take the positional too (e.g. list_tasks query).
+            const fallback = ["query", "work", "repo", "project_id", "task_id", "file_id", "meeting_id", "zone", "path"].find((k) => k in props && !(k in args));
+            if (!fallback)
+                throw usageError(`Unexpected argument "${p}".`, "Pass arguments as --name value or name=value.");
+            setValue(fallback, p);
+            continue;
+        }
+        setValue(slot, p);
+    }
+    return args;
+}
+function expandFileRef(raw, sources) {
+    if (raw === "@-" && sources.readStdin)
+        return sources.readStdin();
+    if (raw.startsWith("@") && raw.length > 1 && sources.readFile && !raw.startsWith("@@")) {
+        try {
+            return sources.readFile(raw.slice(1));
+        }
+        catch {
+            throw usageError(`Could not read file "${raw.slice(1)}".`);
+        }
+    }
+    return raw.startsWith("@@") ? raw.slice(1) : raw;
+}
+/** String → the type the schema wants. Objects/arrays are JSON; arrays also accept comma lists. */
+export function coerceValue(raw, prop, key = "value") {
+    const types = schemaTypes(prop);
+    const trimmed = raw.trim();
+    if (types.includes("null") && /^null$/i.test(trimmed))
+        return null;
+    if (types.includes("boolean") && /^(true|false|yes|no|1|0|on|off)$/i.test(trimmed) && !types.includes("string")) {
+        return /^(true|yes|1|on)$/i.test(trimmed);
+    }
+    if (types.includes("integer") || types.includes("number")) {
+        if (/^-?\d+(\.\d+)?([eE][-+]?\d+)?$/.test(trimmed)) {
+            const n = Number(trimmed);
+            if (types.includes("integer") && !Number.isInteger(n))
+                throw usageError(`--${kebab(key)} must be a whole number (got "${raw}").`);
+            checkRange(n, prop, key);
+            return n;
+        }
+        if (!types.includes("string"))
+            throw usageError(`--${kebab(key)} must be a number (got "${raw}").`);
+    }
+    if (types.includes("object")) {
+        if (/^\s*\{/.test(trimmed))
+            return parseJson(trimmed, key);
+        if (!types.includes("string"))
+            throw usageError(`--${kebab(key)} must be a JSON object.`);
+    }
+    if (types.includes("array")) {
+        if (/^\s*\[/.test(trimmed))
+            return parseJson(trimmed, key);
+        const itemTypes = schemaTypes(prop?.items);
+        const parts = trimmed.split(",").map((s) => s.trim()).filter(Boolean);
+        if (itemTypes.includes("object"))
+            throw usageError(`--${kebab(key)} expects a JSON array of objects.`);
+        return parts.map((p) => (itemTypes.includes("integer") || itemTypes.includes("number") ? Number(p) : itemTypes.includes("boolean") ? /^(true|yes|1)$/i.test(p) : p));
+    }
+    if (prop?.enum && !prop.enum.map(String).includes(trimmed)) {
+        const near = closest(trimmed, prop.enum.map(String));
+        throw usageError(`--${kebab(key)} must be one of: ${prop.enum.join(", ")} (got "${raw}").`, near ? `Did you mean "${near}"?` : undefined);
+    }
+    return raw;
+}
+function checkRange(n, prop, key) {
+    if (prop?.minimum !== undefined && n < prop.minimum)
+        throw usageError(`--${kebab(key)} must be at least ${prop.minimum}.`);
+    if (prop?.maximum !== undefined && n > prop.maximum)
+        throw usageError(`--${kebab(key)} must be at most ${prop.maximum}.`);
+}
+function parseJson(text, key) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw usageError(`--${kebab(key)} is not valid JSON.`);
+    }
+}
+/** Missing required arguments, with their descriptions, for a usage error. */
+export function missingRequired(args, schema) {
+    return (schema?.required ?? []).filter((r) => args[r] === undefined);
+}
+export function requireArgs(args, schema, toolName) {
+    const missing = missingRequired(args, schema);
+    if (!missing.length)
+        return;
+    const props = schema?.properties ?? {};
+    const lines = missing.map((m) => `  --${kebab(m)}  ${firstSentence(props[m]?.description ?? "")}`.trimEnd());
+    throw usageError(`${toolName}: missing ${missing.length === 1 ? "argument" : "arguments"} ${missing.map((m) => `--${kebab(m)}`).join(", ")}.`, lines.join("\n"));
+}
+export function firstSentence(text, max = 160) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    const m = /^(.*?[.!?])(\s|$)/.exec(flat);
+    const s = m ? m[1] : flat;
+    return s.length > max ? s.slice(0, max - 1) + "…" : s;
+}

package/dist/render.js

@@ -0,0 +1,117 @@
+import { formatCell } from "./cli/output.js";
+const PREFERRED_COLUMNS = ["key", "id", "number", "title", "name", "status", "priority", "assignee", "due_date", "project", "updated_at", "created_at", "email", "role", "type", "content", "url"];
+const HIDDEN_KEYS = new Set(["ok", "hint"]);
+/**
+ * Generic human rendering for any tool result: scalars as key/value lines, arrays of records as
+ * tables, nested objects indented, anything deeper as JSON. Friendly commands have their own
+ * renderers; this is what `scribeclock <tool>` prints.
+ */
+export function renderResult(out, data, opts = {}) {
+    const scalars = [];
+    const complex = [];
+    for (const [k, v] of Object.entries(data)) {
+        if (HIDDEN_KEYS.has(k) || v === undefined || v === null)
+            continue;
+        if (isScalar(v) || (Array.isArray(v) && v.every(isScalar)))
+            scalars.push([k, v]);
+        else
+            complex.push([k, v]);
+    }
+    if (scalars.length)
+        out.kv(scalars, 0);
+    for (const [k, v] of complex) {
+        out.log("");
+        out.log(out.bold(k) + (Array.isArray(v) ? out.dim(` (${v.length})`) : ""));
+        renderValue(out, v, 1);
+    }
+    if (opts.showHint !== false && typeof data.hint === "string" && !out.quiet) {
+        out.log("");
+        out.log(out.dim(data.hint));
+    }
+}
+export function renderValue(out, v, depth) {
+    const indent = "  ".repeat(depth);
+    if (Array.isArray(v)) {
+        if (v.length === 0) {
+            out.log(`${indent}${out.dim("(none)")}`);
+            return;
+        }
+        if (v.every((x) => x && typeof x === "object" && !Array.isArray(x))) {
+            const rows = v;
+            const columns = pickColumns(rows);
+            if (columns.length) {
+                out.table(columns, rows.map((r) => columns.map((c) => cellOf(r[c]))), { indent: depth * 2 });
+                return;
+            }
+        }
+        for (const item of v) {
+            if (isScalar(item))
+                out.log(`${indent}- ${formatCell(item)}`);
+            else {
+                out.log(`${indent}-`);
+                renderValue(out, item, depth + 1);
+            }
+        }
+        return;
+    }
+    if (v && typeof v === "object") {
+        const entries = Object.entries(v).filter(([, x]) => x !== undefined && x !== null);
+        const scalars = entries.filter(([, x]) => isScalar(x) || (Array.isArray(x) && x.every(isScalar)));
+        const nested = entries.filter(([, x]) => !(isScalar(x) || (Array.isArray(x) && x.every(isScalar))));
+        if (scalars.length)
+            out.kv(scalars, depth * 2);
+        for (const [k, x] of nested) {
+            if (depth >= 3) {
+                out.log(`${indent}${out.dim(k)}  ${JSON.stringify(x)}`);
+                continue;
+            }
+            out.log(`${indent}${out.dim(k)}${Array.isArray(x) ? out.dim(` (${x.length})`) : ""}`);
+            renderValue(out, x, depth + 1);
+        }
+        return;
+    }
+    out.log(`${indent}${formatCell(v)}`);
+}
+export function isScalar(v) {
+    return v === null || v === undefined || ["string", "number", "boolean"].includes(typeof v);
+}
+/** Columns for a table: preferred names first, then other scalar keys, at most 7. */
+export function pickColumns(rows) {
+    const seen = new Map();
+    for (const r of rows)
+        for (const [k, v] of Object.entries(r))
+            if (isScalar(v) || isNamedRef(v))
+                seen.set(k, (seen.get(k) ?? 0) + 1);
+    const keys = [...seen.keys()];
+    const preferred = PREFERRED_COLUMNS.filter((k) => keys.includes(k));
+    const others = keys.filter((k) => !preferred.includes(k) && !/_id$|^id$|_at$|^url$/.test(k));
+    const cols = [...preferred, ...others].filter((k) => k !== "id" || !keys.includes("key"));
+    return cols.slice(0, 7);
+}
+/** { id, name } / { key, title } style references render as their label. */
+function isNamedRef(v) {
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        return false;
+    const o = v;
+    return typeof o.name === "string" || typeof o.title === "string" || typeof o.email === "string";
+}
+export function cellOf(v) {
+    if (isNamedRef(v)) {
+        const o = v;
+        return String(o.key ? `${o.key} ` : "") + String(o.name ?? o.title ?? o.email ?? "");
+    }
+    if (Array.isArray(v))
+        return v.map(cellOf).join(", ");
+    return formatCell(v);
+}
+/** Non-text content blocks (images, files) get a one-line description. */
+export function describeContent(out, content) {
+    for (const block of content) {
+        if (block.type === "image")
+            out.log(out.dim(`[image ${block.mimeType}, ${Math.round((block.data.length * 3) / 4 / 1024)} KB — use --json for the base64, or files get to save it]`));
+        else if (block.type === "resource_link")
+            out.log(out.dim(`[link] ${block.name}: ${block.uri}`));
+        else if (block.type === "resource")
+            out.log(out.dim(`[resource] ${block.resource.uri}${block.resource.mimeType ? ` (${block.resource.mimeType})` : ""}`));
+    }
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+/** Shared types for the ScribeClock CLI. */
+export const EXIT = {
+    OK: 0,
+    ERROR: 1,
+    USAGE: 2,
+    AUTH: 3,
+    CONFLICT: 4,
+    SCOPE: 5,
+};

package/dist/update-check.js

@@ -0,0 +1,28 @@
+/**
+ * Background update check, run detached by update.ts: fetches the latest published version and
+ * writes it into config.json. Never prints anything.
+ */
+import { readFileSync } from "node:fs";
+import { writeJsonPrivate } from "./config.js";
+const configPath = process.argv[2];
+if (configPath) {
+    try {
+        const res = await fetch("https://registry.npmjs.org/scribeclock/latest", { signal: AbortSignal.timeout(4000), headers: { accept: "application/json" } });
+        if (res.ok) {
+            const json = (await res.json());
+            let current = {};
+            try {
+                current = JSON.parse(readFileSync(configPath, "utf8"));
+            }
+            catch {
+                current = {};
+            }
+            if (typeof json.version === "string") {
+                writeJsonPrivate(configPath, { ...current, update_check: { checked_at: new Date().toISOString(), latest: json.version } });
+            }
+        }
+    }
+    catch {
+        /* offline or registry down: try again tomorrow */
+    }
+}

package/dist/update.js

@@ -0,0 +1,47 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** Compare "1.2.3" style versions; true when `latest` is newer than `current`. */
+export function isNewer(latest, current) {
+    const a = latest.split(/[.-]/).map((x) => parseInt(x, 10));
+    const b = current.split(/[.-]/).map((x) => parseInt(x, 10));
+    for (let i = 0; i < 3; i++) {
+        const x = a[i] ?? 0;
+        const y = b[i] ?? 0;
+        if (Number.isNaN(x) || Number.isNaN(y))
+            return false;
+        if (x !== y)
+            return x > y;
+    }
+    return false;
+}
+/**
+ * Prints a one-line notice when a newer version was found by a previous background check, then
+ * spawns a detached check (at most once a day) so this run never waits on the network.
+ */
+export function updateNotice(ctx) {
+    if (ctx.flags.json || ctx.flags.quiet || !ctx.out.isTTY)
+        return;
+    if (ctx.env.CI || ctx.env.SCRIBECLOCK_NO_UPDATE_CHECK)
+        return;
+    const cfg = ctx.config.read();
+    const last = cfg.update_check;
+    if (last?.latest && isNewer(last.latest, ctx.version)) {
+        ctx.out.info(ctx.out.dim(`Update available: scribeclock ${ctx.version} → ${last.latest} (npm install -g scribeclock@latest)`));
+    }
+    const checkedAt = last?.checked_at ? new Date(last.checked_at).getTime() : 0;
+    if (ctx.now().getTime() - checkedAt < DAY_MS)
+        return;
+    // Record the attempt first so concurrent runs do not all spawn a checker.
+    ctx.config.write({ update_check: { checked_at: ctx.now().toISOString(), latest: last?.latest } });
+    try {
+        const script = join(dirname(fileURLToPath(import.meta.url)), "update-check.js");
+        const child = spawn(process.execPath, [script, ctx.config.path], { detached: true, stdio: "ignore" });
+        child.on("error", () => undefined);
+        child.unref();
+    }
+    catch {
+        /* never let the update check affect the command */
+    }
+}

package/dist/util/format.js

@@ -0,0 +1,176 @@
+/** Small formatting helpers shared by commands. */
+export function fmtDuration(seconds, opts = {}) {
+    if (seconds === null || seconds === undefined || !Number.isFinite(seconds))
+        return "";
+    const s = Math.max(0, Math.floor(seconds));
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    if (opts.compact)
+        return h ? `${h}h${String(m).padStart(2, "0")}m` : `${m}m`;
+    if (h)
+        return `${h}h ${m}m`;
+    if (m)
+        return `${m}m`;
+    return `${s}s`;
+}
+export function fmtHours(seconds) {
+    return (seconds / 3600).toFixed(2);
+}
+export function fmtClock(seconds) {
+    const s = Math.max(0, Math.floor(seconds));
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    const sec = s % 60;
+    return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(sec).padStart(2, "0")}`;
+}
+export function fmtDate(iso, opts = {}) {
+    if (!iso)
+        return "";
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return String(iso);
+    const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+    if (!opts.time)
+        return date;
+    return `${date} ${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+export function relTime(iso, now = new Date()) {
+    if (!iso)
+        return "";
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return String(iso);
+    const diff = (d.getTime() - now.getTime()) / 1000;
+    const abs = Math.abs(diff);
+    const [n, unit] = abs < 60 ? [Math.round(abs), "s"] : abs < 3600 ? [Math.round(abs / 60), "m"] : abs < 86400 ? [Math.round(abs / 3600), "h"] : [Math.round(abs / 86400), "d"];
+    return diff < 0 ? `${n}${unit} ago` : `in ${n}${unit}`;
+}
+export function dueLabel(iso, now = new Date()) {
+    if (!iso)
+        return "";
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return String(iso);
+    const days = Math.round((startOfDay(d).getTime() - startOfDay(now).getTime()) / 86400000);
+    if (days < 0)
+        return `overdue ${-days}d`;
+    if (days === 0)
+        return "today";
+    if (days === 1)
+        return "tomorrow";
+    return fmtDate(iso);
+}
+export function startOfDay(d) {
+    const x = new Date(d);
+    x.setHours(0, 0, 0, 0);
+    return x;
+}
+export function endOfDay(d) {
+    const x = startOfDay(d);
+    x.setDate(x.getDate() + 1);
+    return x;
+}
+export function startOfWeek(d) {
+    const x = startOfDay(d);
+    const day = (x.getDay() + 6) % 7; // Monday = 0
+    x.setDate(x.getDate() - day);
+    return x;
+}
+export function startOfMonth(d) {
+    const x = startOfDay(d);
+    x.setDate(1);
+    return x;
+}
+/**
+ * Human date/time input → Date. Accepts ISO-8601, YYYY-MM-DD, HH:MM (today, local), "yesterday",
+ * "today", "tomorrow", "now", and relative "7d" / "2h" / "30m" (that long ago).
+ */
+export function parseWhen(input, now = new Date()) {
+    const s = input.trim().toLowerCase();
+    if (!s)
+        return null;
+    if (s === "now")
+        return new Date(now);
+    if (s === "today")
+        return startOfDay(now);
+    if (s === "yesterday") {
+        const d = startOfDay(now);
+        d.setDate(d.getDate() - 1);
+        return d;
+    }
+    if (s === "tomorrow") {
+        const d = startOfDay(now);
+        d.setDate(d.getDate() + 1);
+        return d;
+    }
+    const rel = /^(\d+)\s*([mhdw])$/.exec(s);
+    if (rel) {
+        const n = Number(rel[1]);
+        const ms = { m: 60000, h: 3600000, d: 86400000, w: 7 * 86400000 }[rel[2]];
+        return new Date(now.getTime() - n * ms);
+    }
+    const hm = /^(\d{1,2}):(\d{2})(?::(\d{2}))?$/.exec(s);
+    if (hm) {
+        const d = startOfDay(now);
+        d.setHours(Number(hm[1]), Number(hm[2]), Number(hm[3] ?? 0), 0);
+        return d;
+    }
+    const ymd = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+    if (ymd)
+        return new Date(Number(ymd[1]), Number(ymd[2]) - 1, Number(ymd[3]));
+    const d = new Date(input);
+    return Number.isNaN(d.getTime()) ? null : d;
+}
+export function slugify(text, max = 48) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, max)
+        .replace(/-+$/g, "");
+}
+export function plural(n, one, many = `${one}s`) {
+    return `${n} ${n === 1 ? one : many}`;
+}
+export function toCsv(rows, columns) {
+    const esc = (v) => {
+        const s = v === null || v === undefined ? "" : String(v);
+        return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+    };
+    return [columns.join(","), ...rows.map((r) => columns.map((c) => esc(r[c])).join(","))].join("\n");
+}
+export function priorityRank(p) {
+    return p === "high" ? 0 : p === "medium" ? 1 : p === "low" ? 2 : 3;
+}
+/** Simple line diff (LCS) → unified-style lines prefixed with " ", "-" or "+". */
+export function diffLines(a, b) {
+    const n = a.length;
+    const m = b.length;
+    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (a[i] === b[j]) {
+            out.push({ op: " ", text: a[i] });
+            i++;
+            j++;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            out.push({ op: "-", text: a[i++] });
+        }
+        else {
+            out.push({ op: "+", text: b[j++] });
+        }
+    }
+    while (i < n)
+        out.push({ op: "-", text: a[i++] });
+    while (j < m)
+        out.push({ op: "+", text: b[j++] });
+    return out;
+}

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "scribeclock",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "ScribeClock from the terminal: tasks, time clock, projects, PRDs, meetings, files, vault and Cloudflare — a thin client over the ScribeClock MCP server.",
+  "license": "UNLICENSED",
+  "author": "Haydar Al-Karar LLC, dba Karar Tech",
+  "homepage": "https://scribeclock.com/help/mcp-server",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Scribe-Clock/ScribeClock.git",
+    "directory": "packages/cli"
+  },
+  "type": "module",
+  "bin": {
+    "scribeclock": "./bin/scribeclock.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
+    "test": "vitest run",
+    "test:integration": "SCRIBECLOCK_INTEGRATION=1 vitest run test/integration.test.ts",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.7"
+  }
+}