scribeclock 0.0.0-stage → 0.1.0

package/dist/commands/meetings.js

@@ -0,0 +1,254 @@
+import { usageError } from "../cli/errors.js";
+import { confirm } from "../cli/confirm.js";
+import { fmtDate, parseWhen } from "../util/format.js";
+import { truncate } from "../cli/output.js";
+import { PROJECT_FLAG, cmd, emit, num, projectArg, requirePositional, resolveProjectId, str } from "./_shared.js";
+export const meetingsList = cmd({
+    path: "meetings list",
+    group: "Meetings & docs",
+    summary: "Recorded meetings with status, project and whether minutes / a transcript exist.",
+    tool: "list_meetings",
+    positionals: [{ name: "query", description: "Text over title, summary and minutes." }],
+    flags: [
+        PROJECT_FLAG,
+        { name: "status", alias: "s", type: "string", choices: ["scheduled", "live", "processing", "completed", "failed"], description: "Only this status." },
+        { name: "since", type: "string", placeholder: "<when>", description: "Started at or after (ISO, YYYY-MM-DD, yesterday, 7d…)." },
+        { name: "until", type: "string", placeholder: "<when>", description: "Started before." },
+        { name: "limit", alias: "n", type: "number", description: "Max meetings (default 25)." },
+    ],
+    examples: ["scribeclock meetings list --since 7d", "scribeclock meetings list 'retirement' --status completed"],
+    async run(ctx, inv) {
+        const when = (v) => (typeof v === "string" ? parseWhen(v, ctx.now())?.toISOString() : undefined);
+        const data = await ctx.call("list_meetings", { query: inv.positionals.join(" ") || undefined, project_id: projectArg(ctx, inv), status: str(inv.flags.status), since: when(inv.flags.since), until: when(inv.flags.until), limit: num(inv.flags.limit) });
+        return emit(ctx, data, () => {
+            const meetings = (data.meetings ?? []);
+            if (!meetings.length)
+                ctx.out.log(ctx.out.dim("No meetings."));
+            else
+                ctx.out.table(["id", "title", "status", "started", "minutes", "transcript", "project"], meetings.map((m) => [m.id, truncate(String(m.title ?? ""), 48), m.status, fmtDate(String(m.started_at ?? ""), { time: true }), m.has_minutes ? "yes" : "", Number(m.segment_count ?? 0) ? `${String(m.segment_count)} seg` : "", m.project?.name ?? m.project_name ?? ""]), { maxWidth: 48 });
+        });
+    },
+});
+export const meetingsShow = cmd({
+    path: "meetings show",
+    group: "Meetings & docs",
+    summary: "Summary, AI notes and (with --minutes) the full minutes of a meeting.",
+    tool: "get_meeting",
+    positionals: [{ name: "id", required: true, description: "Meeting id from meetings list." }],
+    flags: [{ name: "minutes", type: "boolean", description: "Include the complete formatted minutes." }],
+    async run(ctx, inv) {
+        const meeting_id = requirePositional(inv, 0, "A meeting id", "scribeclock meetings show <id>");
+        const data = await ctx.call("get_meeting", { meeting_id, include_minutes: Boolean(inv.flags.minutes) });
+        return emit(ctx, data, () => renderMeeting(ctx, data));
+    },
+});
+function renderMeeting(ctx, data) {
+    const m = (data.meeting ?? data);
+    ctx.out.log(ctx.out.bold(String(m.title ?? "Meeting")));
+    ctx.out.kv([
+        ["status", m.status],
+        ["started", m.started_at ? fmtDate(String(m.started_at), { time: true }) : ""],
+        ["ended", m.ended_at ? fmtDate(String(m.ended_at), { time: true }) : ""],
+        ["project", m.project?.name ?? m.project_name],
+        ["recorded by", m.recorded_by?.name ?? m.recorded_by],
+        ["segments", m.segment_count],
+        ["url", m.url ?? `https://scribeclock.com/dashboard/meetings/${String(m.id ?? "")}`],
+    ]);
+    const summary = m.summary ?? data.summary;
+    if (summary) {
+        ctx.out.log("");
+        ctx.out.log(ctx.out.bold("Summary"));
+        ctx.out.log(`  ${String(summary)}`);
+    }
+    const notes = (m.ai_notes ?? data.ai_notes);
+    if (notes && typeof notes === "object") {
+        for (const [k, v] of Object.entries(notes)) {
+            if (!v || (Array.isArray(v) && !v.length))
+                continue;
+            ctx.out.log("");
+            ctx.out.log(ctx.out.bold(k.replace(/_/g, " ")));
+            if (Array.isArray(v))
+                for (const item of v)
+                    ctx.out.log(`  - ${typeof item === "string" ? item : JSON.stringify(item)}`);
+            else
+                ctx.out.log(`  ${String(v)}`);
+        }
+    }
+    else if (typeof notes === "string" && notes) {
+        ctx.out.log("");
+        ctx.out.log(ctx.out.bold("AI notes"));
+        ctx.out.log(notes);
+    }
+    const minutes = m.minutes ?? data.minutes ?? m.minutes_markdown ?? data.minutes_markdown;
+    if (typeof minutes === "string" && minutes) {
+        ctx.out.log("");
+        ctx.out.log(ctx.out.bold("Minutes"));
+        ctx.out.log(minutes);
+    }
+}
+export const meetingsTranscript = cmd({
+    path: "meetings transcript",
+    group: "Meetings & docs",
+    summary: "The spoken transcript ([m:ss] Speaker: text), all pages; --summarize prints the AI summary instead.",
+    tool: ["get_meeting_transcript", "get_meeting"],
+    positionals: [{ name: "id", required: true, description: "Meeting id." }],
+    flags: [
+        { name: "summarize", type: "boolean", description: "Print the meeting's AI summary and notes instead of the raw words." },
+        { name: "from", type: "number", description: "Start at this segment (default 0)." },
+        { name: "limit", alias: "n", type: "number", description: "Segments per page (default 400); all pages are fetched unless --one-page." },
+        { name: "one-page", type: "boolean", description: "Fetch a single page only." },
+        { name: "segments", type: "boolean", description: "Raw segments (JSON objects) instead of text lines." },
+    ],
+    examples: ["scribeclock meetings transcript <id> > transcript.txt", "scribeclock meetings transcript <id> --summarize"],
+    async run(ctx, inv) {
+        const meeting_id = requirePositional(inv, 0, "A meeting id", "scribeclock meetings transcript <id>");
+        if (inv.flags.summarize) {
+            const data = await ctx.call("get_meeting", { meeting_id, include_minutes: false });
+            return emit(ctx, data, () => renderMeeting(ctx, data));
+        }
+        const format = inv.flags.segments ? "segments" : "text";
+        let from_seq = num(inv.flags.from) ?? 0;
+        const pages = [];
+        const texts = [];
+        const segments = [];
+        for (let guard = 0; guard < 200; guard++) {
+            const page = await ctx.call("get_meeting_transcript", { meeting_id, from_seq, limit: num(inv.flags.limit), format });
+            pages.push(page);
+            if (typeof page.transcript === "string")
+                texts.push(page.transcript);
+            if (Array.isArray(page.segments))
+                segments.push(...page.segments);
+            const next = page.next_from_seq;
+            if (inv.flags["one-page"] || next === null || next === undefined || Number(next) <= from_seq)
+                break;
+            from_seq = Number(next);
+        }
+        if (ctx.flags.json) {
+            ctx.out.jsonOut({ ok: true, meeting_id, pages: pages.length, ...(format === "segments" ? { segments } : { transcript: texts.join("\n") }) });
+            return 0;
+        }
+        if (format === "segments")
+            for (const s of segments)
+                ctx.out.ndjson(s);
+        else
+            ctx.out.log(texts.join("\n"));
+        return 0;
+    },
+});
+/** Action-item extraction from AI notes / minutes / summary: structured first, then line heuristics. */
+export function extractActionItems(meeting) {
+    const items = [];
+    const push = (raw, source) => {
+        if (!raw)
+            return;
+        if (typeof raw === "object" && !Array.isArray(raw)) {
+            const o = raw;
+            const title = String(o.title ?? o.text ?? o.action ?? o.item ?? "").trim();
+            if (title)
+                items.push({ title: title.slice(0, 140), owner: typeof o.owner === "string" ? o.owner : typeof o.assignee === "string" ? o.assignee : undefined, source });
+            return;
+        }
+        const text = String(raw).replace(/^[-*•]\s*(\[[ xX]?\]\s*)?/, "").trim();
+        if (text.length < 6)
+            return;
+        const owner = /^\*{0,2}([A-Z][\w.'-]+(?: [A-Z][\w.'-]+)?)\*{0,2}\s*(?::|will|to)\s/.exec(text)?.[1];
+        items.push({ title: text.replace(/\*\*/g, "").slice(0, 140), owner, source });
+    };
+    const notes = (meeting.ai_notes ?? {});
+    for (const key of ["action_items", "actions", "next_steps", "tasks", "follow_ups"]) {
+        const v = notes[key] ?? meeting[key];
+        if (Array.isArray(v))
+            for (const item of v)
+                push(item, `ai_notes.${key}`);
+    }
+    if (!items.length) {
+        const text = [meeting.minutes, meeting.minutes_markdown, meeting.summary].filter((x) => typeof x === "string").join("\n");
+        let inActions = false;
+        for (const line of text.split("\n")) {
+            if (/^#{1,6}\s*(action items?|next steps|follow[- ]?ups?|to[- ]?dos?)\b/i.test(line) || /^\*\*(action items?|next steps)\*\*/i.test(line)) {
+                inActions = true;
+                continue;
+            }
+            if (/^#{1,6}\s/.test(line))
+                inActions = false;
+            if ((inActions && /^\s*([-*•]|\d+\.)\s+\S/.test(line)) || /^\s*[-*]\s+\[ \]\s+/.test(line) || /\b(action item|TODO)\b/i.test(line))
+                push(line.replace(/^\s*\d+\.\s*/, ""), "minutes");
+        }
+    }
+    const seen = new Set();
+    return items.filter((i) => {
+        const k = i.title.toLowerCase();
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        return true;
+    });
+}
+export const meetingsActions = cmd({
+    path: "meetings actions",
+    group: "Meetings & docs",
+    summary: "Action items from a meeting's notes; --create-tasks files them as tasks after you confirm.",
+    tool: ["get_meeting", "create_task"],
+    positionals: [{ name: "id", required: true, description: "Meeting id." }],
+    flags: [
+        { name: "create-tasks", type: "boolean", description: "Create a task per action item (asks first; --yes to skip)." },
+        PROJECT_FLAG,
+        { name: "assignee", alias: "a", type: "string", description: "Assignee for the created tasks (default: the owner named in the item, when it matches a member)." },
+        { name: "priority", type: "string", choices: ["low", "medium", "high"], description: "Priority for created tasks." },
+    ],
+    examples: ["scribeclock meetings actions <id>", "scribeclock meetings actions <id> --create-tasks --project 'Kisa Print'"],
+    async run(ctx, inv) {
+        const meeting_id = requirePositional(inv, 0, "A meeting id", "scribeclock meetings actions <id>");
+        const data = await ctx.call("get_meeting", { meeting_id, include_minutes: true });
+        const meeting = (data.meeting ?? data);
+        const items = extractActionItems({ ...meeting, ...data });
+        if (!inv.flags["create-tasks"]) {
+            return emit(ctx, { ok: true, meeting_id, title: meeting.title, count: items.length, action_items: items }, () => {
+                ctx.out.log(ctx.out.bold(`Action items from "${String(meeting.title ?? meeting_id)}" (${items.length})`));
+                if (!items.length)
+                    ctx.out.log(ctx.out.dim("None found in the AI notes or minutes."));
+                else
+                    ctx.out.table(["#", "action", "owner", "source"], items.map((it, i) => [i + 1, it.title, it.owner ?? "", it.source]));
+                if (items.length)
+                    ctx.out.info(ctx.out.dim("Add --create-tasks to file them."));
+            });
+        }
+        if (!items.length)
+            throw usageError("No action items to create.");
+        const project_id = (await resolveProjectId(ctx, projectArg(ctx, inv))) ?? meeting.project?.id;
+        if (!ctx.flags.dryRun) {
+            ctx.out.info(items.map((it, i) => `  ${i + 1}. ${it.title}${it.owner ? ctx.out.dim(` (${it.owner})`) : ""}`).join("\n"));
+            const ok = await confirm(ctx, `Create these ${items.length} tasks${project_id ? ` in project ${project_id}` : ""}?`);
+            if (!ok)
+                return 1;
+        }
+        const link = `https://scribeclock.com/dashboard/meetings/${meeting_id}`;
+        const created = [];
+        for (const it of items) {
+            const args = { title: it.title, description: `From the meeting "${String(meeting.title ?? "")}" (${fmtDate(String(meeting.started_at ?? ""))}).\n\nMeeting notes: ${link}`, project_id, priority: str(inv.flags.priority), assignee: str(inv.flags.assignee) ?? it.owner };
+            if (ctx.flags.dryRun) {
+                ctx.out.log(`${ctx.out.dim("dry run →")} create_task ${JSON.stringify({ title: it.title, project_id, assignee: args.assignee })}`);
+                continue;
+            }
+            let r;
+            try {
+                r = await ctx.call("create_task", args);
+            }
+            catch (err) {
+                // An owner name that is not a member: retry unassigned rather than losing the item.
+                if (args.assignee && !str(inv.flags.assignee))
+                    r = await ctx.call("create_task", { ...args, assignee: undefined });
+                else
+                    throw err;
+            }
+            created.push((r.task ?? r));
+            ctx.out.info(`${ctx.out.green("✓")} ${String((r.task ?? r).key ?? "")} ${it.title}`);
+        }
+        if (ctx.flags.json)
+            ctx.out.jsonOut({ ok: true, created: created.length, tasks: created });
+        else if (!ctx.flags.dryRun)
+            ctx.out.log(`Created ${created.length} tasks from the meeting.`);
+        return 0;
+    },
+});
+export const MEETING_COMMANDS = [meetingsList, meetingsShow, meetingsTranscript, meetingsActions];

package/dist/commands/meta.js

@@ -0,0 +1,129 @@
+import { renderCommandHelp, renderGlobalHelp } from "../cli/registry.js";
+import { usageError } from "../cli/errors.js";
+import { EXIT } from "../types.js";
+export const versionCommand = {
+    path: "version",
+    group: "Getting started",
+    summary: "Print the CLI version.",
+    hidden: true,
+    async run(ctx) {
+        if (ctx.flags.json)
+            ctx.out.jsonOut({ ok: true, version: ctx.version, endpoint: ctx.endpoint, node: process.version });
+        else
+            ctx.out.log(`scribeclock ${ctx.version}`);
+        return EXIT.OK;
+    },
+};
+export const helpCommand = {
+    path: "help",
+    group: "Getting started",
+    summary: "Show help for a command: help tasks list.",
+    positionals: [{ name: "command", variadic: true }],
+    async run(ctx, inv) {
+        if (!inv.positionals.length) {
+            renderGlobalHelp(ctx.out, ctx.registry, ctx.version, null);
+            return EXIT.OK;
+        }
+        const resolved = ctx.registry.resolve(inv.positionals);
+        if (resolved) {
+            renderCommandHelp(ctx.out, resolved.command);
+            return EXIT.OK;
+        }
+        const children = ctx.registry.children(inv.positionals[0]);
+        if (children.length) {
+            ctx.out.log(ctx.out.bold(`scribeclock ${inv.positionals[0]} <subcommand>`));
+            const w = Math.max(...children.map((c) => c.path.length));
+            for (const c of children)
+                ctx.out.log(`  ${ctx.out.cyan(c.path.padEnd(w))}  ${c.summary}`);
+            return EXIT.OK;
+        }
+        const { findTool, renderToolHelp } = await import("./tools.js");
+        const tool = await findTool(ctx, inv.positionals[0]).catch(() => undefined);
+        if (tool) {
+            renderToolHelp(ctx, tool);
+            return EXIT.OK;
+        }
+        throw usageError(`No command or tool named "${inv.positionals.join(" ")}".`, "`scribeclock --help` lists commands; `scribeclock tools` lists server tools.");
+    },
+};
+const SHELLS = ["bash", "zsh", "fish"];
+export const completionsCommand = {
+    path: "completions",
+    group: "Getting started",
+    summary: "Shell completion script (bash, zsh, fish), including the live tool names.",
+    description: "Prints a completion script. Commands come from the CLI, tool names from the cached catalog (log in and run `scribeclock refresh` first so they are included).\n\n  bash: scribeclock completions bash > ~/.local/share/bash-completion/completions/scribeclock\n  zsh:  scribeclock completions zsh > ~/.zfunc/_scribeclock   (add ~/.zfunc to fpath)\n  fish: scribeclock completions fish > ~/.config/fish/completions/scribeclock.fish",
+    positionals: [{ name: "shell", required: true, description: "bash, zsh or fish" }],
+    async run(ctx, inv) {
+        const shell = inv.positionals[0];
+        if (!SHELLS.includes(shell))
+            throw usageError(`Unknown shell "${shell}".`, `One of: ${SHELLS.join(", ")}`);
+        const commands = ctx.registry.list().filter((c) => !c.hidden);
+        const top = Array.from(new Set(commands.map((c) => c.path.split(" ")[0])));
+        const subs = new Map();
+        for (const c of commands) {
+            const [a, b] = c.path.split(" ");
+            if (b)
+                subs.set(a, [...(subs.get(a) ?? []), b]);
+        }
+        let toolNames = [];
+        try {
+            const cached = ctx.catalog.readCache();
+            if (cached)
+                toolNames = cached.tools.map((t) => t.name);
+            else
+                toolNames = (await ctx.tools()).map((t) => t.name);
+        }
+        catch {
+            toolNames = [];
+        }
+        const globals = ["--json", "--org", "--yes", "--dry-run", "--url", "--quiet", "--no-color", "--debug", "--reveal", "--help", "--version"];
+        const words = [...top, ...toolNames];
+        if (shell === "bash") {
+            const cases = [...subs.entries()].map(([k, v]) => `      ${k}) COMPREPLY=( $(compgen -W "${v.join(" ")} ${globals.join(" ")}" -- "$cur") ); return;;`).join("\n");
+            ctx.out.log(`# bash completion for scribeclock
+_scribeclock() {
+  local cur prev
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  if [[ $COMP_CWORD -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "${words.join(" ")} ${globals.join(" ")}" -- "$cur") ); return
+  fi
+  case "\${COMP_WORDS[1]}" in
+${cases}
+  esac
+  COMPREPLY=( $(compgen -W "${globals.join(" ")}" -- "$cur") )
+}
+complete -F _scribeclock scribeclock`);
+        }
+        else if (shell === "zsh") {
+            const subBlocks = [...subs.entries()].map(([k, v]) => `    ${k}) _values 'subcommand' ${v.map((s) => `'${s}'`).join(" ")} ;;`).join("\n");
+            ctx.out.log(`#compdef scribeclock
+_scribeclock() {
+  local -a cmds
+  cmds=(${words.map((w) => `'${w}'`).join(" ")})
+  if (( CURRENT == 2 )); then
+    _describe 'command' cmds
+    return
+  fi
+  case $words[2] in
+${subBlocks}
+    *) _arguments ${globals.map((g) => `'${g}'`).join(" ")} ;;
+  esac
+}
+_scribeclock "$@"`);
+        }
+        else {
+            const lines = [`# fish completion for scribeclock`, `complete -c scribeclock -f`];
+            for (const w of words)
+                lines.push(`complete -c scribeclock -n "__fish_use_subcommand" -a ${w}`);
+            for (const [k, v] of subs)
+                for (const s of v)
+                    lines.push(`complete -c scribeclock -n "__fish_seen_subcommand_from ${k}" -a ${s}`);
+            for (const g of globals)
+                lines.push(`complete -c scribeclock -l ${g.replace(/^--/, "")}`);
+            ctx.out.log(lines.join("\n"));
+        }
+        return EXIT.OK;
+    },
+};