@scira/cli 0.1.0

package/dist/utils/markdown-joiner.js

@@ -0,0 +1,249 @@
+// Regex patterns for markdown matching
+const LINK_PATTERN = /^\[.*?\]\(.*?\)$/;
+const BOLD_PATTERN = /^\*\*.*?\*\*$/;
+// Matches *text* but NOT **text** (negative lookahead ensures second char isn't *)
+const ITALIC_PATTERN = /^\*(?!\*).+\*$/;
+const TABLE_ROW_PATTERN = /^\|.+\|$/;
+// Matches markdown table delimiter rows like: | --- | ---: | :-: |
+const TABLE_DELIMITER_PATTERN = /^\|\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)*\|\s*$/;
+const WHITESPACE_PATTERN = /\s/;
+// Rich XML tags that must be passed through intact
+const RICH_TAGS = ['app_preview', 'download'];
+// Matches an opening rich tag e.g. <app_preview> or <download>
+const RICH_TAG_OPEN_RE = new RegExp(`<(${RICH_TAGS.join('|')})>`, 'i');
+// Inline buffer cap: flush as raw text if a markdown element doesn't close within this many chars
+const MAX_INLINE_BUFFER = 512;
+// Rich-tag buffer cap: safety valve for malformed/missing closing tags
+const MAX_RICH_TAG_BUFFER = 65536;
+class MarkdownJoiner {
+    buffer = '';
+    bufferMode = null;
+    richTagName = null;
+    tableLineBuffer = '';
+    tableLineMode = null;
+    isAtLineStart = true;
+    isInTable = false;
+    pendingTableHeaderLine = null;
+    processText(text) {
+        let output = '';
+        for (const char of text) {
+            // Rich-tag passthrough mode: buffer everything until closing tag
+            if (this.bufferMode === 'rich-tag') {
+                this.buffer += char;
+                // Safety cap: if the rich tag never closes, flush as raw text
+                if (this.buffer.length > MAX_RICH_TAG_BUFFER) {
+                    output += this.buffer;
+                    this.richTagName = null;
+                    this.clearBuffer();
+                    this.isAtLineStart = char === '\n';
+                    continue;
+                }
+                const closeTag = `</${this.richTagName}>`;
+                if (this.buffer.endsWith(closeTag)) {
+                    output += this.buffer;
+                    this.richTagName = null;
+                    this.clearBuffer();
+                }
+                continue;
+            }
+            if (this.tableLineMode) {
+                this.tableLineBuffer += char;
+                if (char === '\n') {
+                    output += this.flushTableLine();
+                    this.isAtLineStart = true;
+                }
+                else {
+                    this.isAtLineStart = false;
+                }
+            }
+            else if (this.bufferMode === 'inline') {
+                this.buffer += char;
+                // Cap inline buffer to prevent quadratic regex cost on unbounded input
+                if (this.buffer.length > MAX_INLINE_BUFFER) {
+                    output += this.buffer;
+                    this.clearBuffer();
+                    this.isAtLineStart = char === '\n';
+                    continue;
+                }
+                // Check if buffer has grown into a rich tag opener
+                if (this.buffer.startsWith('<')) {
+                    const match = RICH_TAG_OPEN_RE.exec(this.buffer);
+                    if (match && this.buffer.endsWith('>')) {
+                        // Confirmed rich tag open — switch to rich-tag mode
+                        this.richTagName = match[1];
+                        this.bufferMode = 'rich-tag';
+                        this.isAtLineStart = false;
+                        continue;
+                    }
+                    // Still potentially building a rich tag — keep buffering until > or mismatch
+                    if (!this.isFalsePositiveTag(char)) {
+                        this.isAtLineStart = char === '\n';
+                        continue;
+                    }
+                    // Not a rich tag — flush as raw text
+                    output += this.buffer;
+                    this.clearBuffer();
+                    this.isAtLineStart = char === '\n';
+                    continue;
+                }
+                // Check for complete markdown elements or false positives
+                if (this.isCompleteLink() || this.isCompleteBold() || this.isCompleteItalic()) {
+                    // Complete markdown element - flush buffer as is
+                    output += this.buffer;
+                    this.clearBuffer();
+                }
+                else if (this.isFalsePositive(char)) {
+                    // False positive - flush buffer as raw text
+                    output += this.buffer;
+                    this.clearBuffer();
+                }
+                this.isAtLineStart = char === '\n';
+            }
+            else {
+                if (this.isAtLineStart) {
+                    if (this.pendingTableHeaderLine) {
+                        if (char !== '|') {
+                            output += this.pendingTableHeaderLine;
+                            this.pendingTableHeaderLine = null;
+                            // fall through to handle this char normally
+                        }
+                        else {
+                            this.tableLineMode = 'delimiter';
+                            this.tableLineBuffer = char;
+                            this.isAtLineStart = false;
+                            continue;
+                        }
+                    }
+                    if (this.isInTable && char !== '|')
+                        this.isInTable = false;
+                    if (!this.isInTable && !this.pendingTableHeaderLine && char === '|') {
+                        this.tableLineMode = 'header';
+                        this.tableLineBuffer = char;
+                        this.isAtLineStart = false;
+                        continue;
+                    }
+                }
+                if (char === '<') {
+                    this.buffer = char;
+                    this.bufferMode = 'inline';
+                    this.isAtLineStart = false;
+                    continue;
+                }
+                if (char === '[' || char === '*') {
+                    this.buffer = char;
+                    this.bufferMode = 'inline';
+                    this.isAtLineStart = false;
+                    continue;
+                }
+                // Pass through character directly
+                output += char;
+                this.isAtLineStart = char === '\n';
+            }
+        }
+        return output;
+    }
+    flushTableLine() {
+        const lineWithNewline = this.tableLineBuffer;
+        const line = lineWithNewline.endsWith('\n') ? lineWithNewline.slice(0, -1) : lineWithNewline;
+        this.tableLineBuffer = '';
+        const mode = this.tableLineMode;
+        this.tableLineMode = null;
+        if (mode === 'header') {
+            if (this.isTableHeaderCandidate(line)) {
+                // Hold header line until we see whether next line is a delimiter row
+                this.pendingTableHeaderLine = lineWithNewline;
+                return '';
+            }
+            return lineWithNewline;
+        }
+        if (mode === 'delimiter') {
+            const headerLine = this.pendingTableHeaderLine ?? '';
+            this.pendingTableHeaderLine = null;
+            if (TABLE_DELIMITER_PATTERN.test(line))
+                this.isInTable = true;
+            return headerLine + lineWithNewline;
+        }
+        return lineWithNewline;
+    }
+    isTableHeaderCandidate(line) {
+        return TABLE_ROW_PATTERN.test(line) && !TABLE_DELIMITER_PATTERN.test(line);
+    }
+    isCompleteLink() {
+        // Match [text](url) pattern
+        return LINK_PATTERN.test(this.buffer);
+    }
+    isCompleteBold() {
+        // Match **text** pattern
+        return BOLD_PATTERN.test(this.buffer);
+    }
+    isCompleteItalic() {
+        // Match *text* pattern (but not **text**)
+        return ITALIC_PATTERN.test(this.buffer);
+    }
+    isFalsePositiveTag(char) {
+        // A < buffer is a false positive if we hit newline, another <, or > without matching a rich tag
+        if (char === '\n' || (char === '<' && this.buffer.length > 1))
+            return true;
+        if (char === '>' && !RICH_TAG_OPEN_RE.test(this.buffer))
+            return true;
+        return false;
+    }
+    isFalsePositive(char) {
+        // For links: if we see [ followed by something other than valid link syntax
+        if (this.buffer.startsWith('[')) {
+            // If we hit a newline or another [ without completing the link, it's false positive
+            return char === '\n' || (char === '[' && this.buffer.length > 1);
+        }
+        // For emphasis: if we see * or ** followed by whitespace or newline
+        if (this.buffer.startsWith('*')) {
+            // Single * followed by whitespace is likely a list item or not emphasis
+            // (buffer already includes char, so length 2 means just "*" + the whitespace char)
+            if (this.buffer.length === 2 && WHITESPACE_PATTERN.test(char)) {
+                return true;
+            }
+            // If we hit newline without completing emphasis, it's false positive
+            return char === '\n';
+        }
+        return false;
+    }
+    clearBuffer() {
+        this.buffer = '';
+        this.bufferMode = null;
+    }
+    flush() {
+        const remaining = (this.pendingTableHeaderLine ?? '') + this.tableLineBuffer + this.buffer;
+        this.pendingTableHeaderLine = null;
+        this.tableLineBuffer = '';
+        this.tableLineMode = null;
+        this.clearBuffer();
+        return remaining;
+    }
+}
+export const markdownJoinerTransform = () => () => {
+    const joiner = new MarkdownJoiner();
+    return new TransformStream({
+        transform(chunk, controller) {
+            if (chunk.type === 'text-delta') {
+                const processedText = joiner.processText(chunk.text);
+                if (processedText) {
+                    controller.enqueue({
+                        ...chunk,
+                        text: processedText,
+                    });
+                }
+            }
+            else {
+                controller.enqueue(chunk);
+            }
+        },
+        flush(controller) {
+            const remaining = joiner.flush();
+            if (remaining) {
+                controller.enqueue({
+                    type: 'text-delta',
+                    text: remaining,
+                });
+            }
+        },
+    });
+};

package/dist/watch/runner.js

@@ -0,0 +1,65 @@
+import { readFile } from "node:fs/promises";
+import { diffLines } from "diff";
+import { createRun, listRuns, getRunPaths } from "../storage/run-store.js";
+import { runResearchAgent } from "../agent/research-agent.js";
+/** Compare two report.md texts and return a human-readable diff summary. */
+export function diffReports(prev, next) {
+    const changes = diffLines(prev, next);
+    const added = changes.filter((c) => c.added).map((c) => c.value.trim()).filter(Boolean);
+    const removed = changes.filter((c) => c.removed).map((c) => c.value.trim()).filter(Boolean);
+    if (added.length === 0 && removed.length === 0)
+        return "No changes detected.";
+    const lines = [];
+    if (added.length > 0) {
+        lines.push(`+++ ${added.length} added section(s):\n${added.map((a) => `  + ${a.slice(0, 120)}`).join("\n")}`);
+    }
+    if (removed.length > 0) {
+        lines.push(`--- ${removed.length} removed section(s):\n${removed.map((r) => `  - ${r.slice(0, 120)}`).join("\n")}`);
+    }
+    return lines.join("\n");
+}
+async function getLastReport(goal, config, projectRoot) {
+    const runs = await listRuns(config, projectRoot);
+    const last = runs.find((r) => r.goal === goal || r.goal.includes(goal));
+    if (!last)
+        return "";
+    return readFile(getRunPaths(last.path).report, "utf8").catch(() => "");
+}
+/**
+ * Run the watch loop. Resolves when maxRuns is reached or signal is aborted.
+ */
+export async function watchLoop(opts, signal) {
+    const { goal, intervalMs, maxRuns, config, projectRoot = process.cwd() } = opts;
+    let tick = 0;
+    while (!signal?.aborted) {
+        if (maxRuns !== undefined && tick >= maxRuns)
+            break;
+        const prevReport = await getLastReport(goal, config, projectRoot);
+        let runPath;
+        try {
+            const state = await createRun(goal, config, projectRoot);
+            runPath = state.path;
+        }
+        catch (err) {
+            opts.onError?.(err instanceof Error ? err : new Error(String(err)), tick);
+            break;
+        }
+        opts.onRunStart?.(runPath, tick);
+        try {
+            await runResearchAgent(runPath, goal, config);
+            const nextReport = await readFile(getRunPaths(runPath).report, "utf8").catch(() => "");
+            const diffText = diffReports(prevReport, nextReport);
+            opts.onRunComplete?.(runPath, diffText, tick);
+        }
+        catch (err) {
+            opts.onError?.(err instanceof Error ? err : new Error(String(err)), tick);
+        }
+        tick++;
+        if (maxRuns !== undefined && tick >= maxRuns)
+            break;
+        await new Promise((resolve) => {
+            const id = setTimeout(resolve, intervalMs);
+            signal?.addEventListener("abort", () => { clearTimeout(id); resolve(); }, { once: true });
+        });
+    }
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@scira/cli",
+  "version": "0.1.0",
+  "description": "Scira — terminal-native AI research agent with grounded sources, verified claims, and local run storage.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "scira": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "research",
+    "ai",
+    "cli",
+    "agent",
+    "llm",
+    "rag"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zaidmukaddam/scira-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/zaidmukaddam/scira-cli/issues"
+  },
+  "homepage": "https://github.com/zaidmukaddam/scira-cli#readme",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "bun run build",
+    "dev": "tsx src/cli/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@ai-sdk/mcp": "^1.0.47",
+    "@ai-sdk/openai-compatible": "^2.0.48",
+    "@ai-sdk/xai": "^3.0.93",
+    "@clack/prompts": "^1.5.1",
+    "@mendable/firecrawl-js": "^4.25.3",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@mozilla/readability": "^0.6.0",
+    "ai": "^6.0.201",
+    "bash-tool": "^1.3.17",
+    "commander": "^15.0.0",
+    "diff": "^9.0.0",
+    "exa-js": "^2.13.0",
+    "files-sdk": "^1.8.0",
+    "ink": "^7.0.5",
+    "jsdom": "^29.1.1",
+    "ora": "^9.4.0",
+    "parallel-web": "^1.1.0",
+    "react": "^19.2.7",
+    "string-width": "8.2.1",
+    "workers-ai-provider": "^3.1.14",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/jsdom": "^28.0.3",
+    "@types/node": "^25.9.3",
+    "@types/react": "^19.2.17",
+    "@vitest/coverage-v8": "^4.1.8",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}