@oxecli/oxe 1.0.0

package/dist/engine.js

@@ -0,0 +1,534 @@
+import OpenAI from "openai";
+import { max_output_tokens, max_empty_retries, max_agent_steps, max_context_tokens, context_overhead_margin, compact_keep_recent_turns, max_summary_source_chars, max_read_file_stored_chars, } from "./config.js";
+import { SYSTEM_PROMPT } from "./system.js";
+import { buildTools, truncateToolOutput, TOOL_IMPLEMENTATIONS } from "./tools.js";
+import { mutedMarkdown, aiMarkdown, tickDuration, safeCommitPoint, printAiChunk, formatToolAction, } from "./ui.js";
+import { reportUsage } from "./api.js";
+import { stripOrphanCalls, persistCompactionSummary, toolOutputFailed, } from "./sessions.js";
+// ---------------------------------------------------------------------------
+// Token estimation (heuristic, mirrors Python fallback)
+// ---------------------------------------------------------------------------
+const tokenEstCache = new Map();
+const tokenEstCacheMax = 4096;
+export function estimateTokens(items) {
+    let total = 0;
+    for (const item of items) {
+        const cid = objectId(item);
+        let n = tokenEstCache.get(cid);
+        if (n === undefined) {
+            const payload = JSON.stringify(item);
+            n = Math.floor(payload.length / 3) + 1;
+            if (tokenEstCache.size < tokenEstCacheMax)
+                tokenEstCache.set(cid, n);
+        }
+        total += n;
+    }
+    return total;
+}
+let idCounter = 0;
+const objectId = (() => {
+    const ids = new WeakMap();
+    return (obj) => {
+        if (!ids.has(obj))
+            ids.set(obj, ++idCounter);
+        return ids.get(obj);
+    };
+})();
+// ---------------------------------------------------------------------------
+// Simple status line helper
+// ---------------------------------------------------------------------------
+class Status {
+    text;
+    timer = null;
+    started;
+    constructor(initial) {
+        this.text = initial;
+        this.started = Date.now();
+    }
+    start() {
+        process.stdout.write("\r\x1b[2K" + mutedMarkdown(this.text) + "\n");
+    }
+    update(text) {
+        this.text = text;
+        process.stdout.write("\r\x1b[2K" + mutedMarkdown(text) + "\x1b[1A");
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+}
+// ---------------------------------------------------------------------------
+// InferenceEngine
+// ---------------------------------------------------------------------------
+export class InferenceEngine {
+    modelName;
+    reasoningEffort;
+    keyData;
+    client;
+    inQuery = false;
+    temperature;
+    storedResponseIds = [];
+    constructor(config) {
+        this.modelName = config["model_name"];
+        this.reasoningEffort = config["reasoning_effort"];
+        this.keyData = config["key_data"] || {};
+        this.client = new OpenAI({
+            apiKey: config["api_key"],
+            baseURL: config["base_url"],
+            timeout: config["timeout"] ?? 120,
+            maxRetries: config["max_retries"] ?? 2,
+        });
+        this.temperature = config["temperature"] ?? null;
+    }
+    async cleanupStoredResponses() {
+        const ids = this.storedResponseIds;
+        this.storedResponseIds = [];
+        for (const rid of ids) {
+            try {
+                await this.client.responses.delete(rid);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    async runTool(name, argumentsJson) {
+        let args = {};
+        try {
+            args = argumentsJson ? JSON.parse(argumentsJson) : {};
+        }
+        catch {
+            args = {};
+        }
+        try {
+            const impl = TOOL_IMPLEMENTATIONS[name];
+            if (!impl)
+                return `Error: unknown tool '${name}'`;
+            const result = await impl(...Object.values(args));
+            return typeof result === "string" ? result : String(result);
+        }
+        catch (err) {
+            return `Error: ${err}`;
+        }
+    }
+    diagnoseEmptyResponse(response, reasoned = false) {
+        for (const item of response?.output ?? []) {
+            if (item?.type === "message") {
+                for (const part of item?.content ?? []) {
+                    if (part?.type === "refusal") {
+                        return `(refused: ${part?.refusal ?? "no reason given"})`;
+                    }
+                }
+            }
+        }
+        const incomplete = response?.incomplete_details;
+        const reason = incomplete?.reason ?? null;
+        if (reason)
+            return `(empty response: ${reason})`;
+        const status = response?.status;
+        if (status && status !== "completed")
+            return `(empty response: status=${status})`;
+        if (reasoned)
+            return "(model reasoned but returned no text or tool call)";
+        return "(empty response from the model — no text, no tool calls)";
+    }
+    incompleteReason(response) {
+        return response?.incomplete_details?.reason ?? null;
+    }
+    async streamOnce(inputItems, stats, story, previousResponseId) {
+        let content = "";
+        let committedLen = 0;
+        let pending = "";
+        let sawReasoning = false;
+        let status = null;
+        const thinkingStart = Date.now();
+        const workStatus = new Status("Working for `0s`");
+        workStatus.start();
+        let response = null;
+        let etype = null;
+        const finishThinking = (report) => {
+            if (status) {
+                status.stop();
+                status = null;
+            }
+            if (report) {
+                const elapsed = (Date.now() - thinkingStart) / 1000;
+                const t = tickDuration(elapsed);
+                story.push({ type: "thought", text: `Thought for ${t}` });
+                process.stdout.write("\n" + mutedMarkdown(`Thought for ${t}`) + "\n");
+            }
+        };
+        try {
+            const kwargs = {
+                model: this.modelName,
+                instructions: SYSTEM_PROMPT,
+                input: inputItems.map((item) => {
+                    const copy = { ...item };
+                    delete copy["footer"];
+                    delete copy["paste_spans"];
+                    delete copy["compaction_summary"];
+                    return copy;
+                }),
+                tools: buildTools(),
+                tool_choice: "auto",
+                parallel_tool_calls: true,
+                max_output_tokens,
+                reasoning: { effort: this.reasoningEffort },
+                stream_options: { include_usage: true },
+                store: true,
+            };
+            if (this.temperature !== null)
+                kwargs["temperature"] = this.temperature;
+            if (previousResponseId)
+                kwargs["previous_response_id"] = previousResponseId;
+            const stream = await this.client.responses.create(kwargs);
+            for await (const event of stream) {
+                etype = event.type;
+                if (etype === "response.reasoning_text.delta" ||
+                    etype === "response.reasoning.summary.delta") {
+                    sawReasoning = true;
+                    if (!status) {
+                        status = new Status("Thinking for `0s`");
+                        status.start();
+                    }
+                    else {
+                        const elapsed = (Date.now() - thinkingStart) / 1000;
+                        status.update(`Thinking for ${tickDuration(elapsed)}`);
+                    }
+                }
+                else if (etype === "response.reasoning_text.done" ||
+                    etype === "response.reasoning.summary.done") {
+                    finishThinking(true);
+                }
+                else if (etype === "response.output_text.delta") {
+                    finishThinking(true);
+                    content += event.delta;
+                    pending += event.delta;
+                    if (pending.includes("\n\n")) {
+                        const cut = safeCommitPoint(content);
+                        if (cut > committedLen) {
+                            printAiChunk(content.slice(committedLen, cut));
+                            committedLen = cut;
+                            pending = content.slice(committedLen);
+                        }
+                    }
+                }
+                else if (etype === "response.completed" ||
+                    etype === "response.incomplete" ||
+                    etype === "response.failed") {
+                    response = event.response;
+                }
+            }
+        }
+        finally {
+            workStatus.stop();
+            finishThinking(true);
+            if (content.slice(committedLen))
+                printAiChunk(content.slice(committedLen));
+        }
+        if (!response) {
+            throw new Error("Stream ended without a completed response");
+        }
+        if (etype === "response.failed") {
+            throw new Error(`DeepSeek response failed: ${response?.error}`);
+        }
+        const usage = response?.usage;
+        if (usage) {
+            stats["input"] = (stats["input"] ?? 0) + (usage?.input_tokens ?? 0);
+            const outTok = usage?.output_tokens ??
+                usage?.total_tokens ??
+                0;
+            stats["tokens"] = (stats["tokens"] ?? 0) + outTok;
+            const reasoningTok = usage?.output_tokens_details?.reasoning_tokens ?? 0;
+            stats["reasoning"] = (stats["reasoning"] ?? 0) + reasoningTok;
+        }
+        const calls = (response?.output ?? [])
+            .filter((item) => item?.type === "function_call")
+            .map((item) => ({
+            id: item?.call_id ?? item?.id,
+            name: item?.name,
+            arguments: item?.arguments,
+        }));
+        const outputItems = (response?.output ?? [])
+            .filter((item) => item?.type !== "reasoning" && item?.type !== "reasoning.summary")
+            .map((item) => JSON.parse(JSON.stringify(item)));
+        const text = response?.output_text ?? content;
+        if (text.trim())
+            story.push({ type: "assistant", text });
+        let incompleteReason = null;
+        let emptyMessage = null;
+        if (!text.trim() && calls.length === 0) {
+            incompleteReason = this.incompleteReason(response);
+            emptyMessage = this.diagnoseEmptyResponse(response, sawReasoning);
+        }
+        return {
+            text,
+            calls,
+            outputItems,
+            incompleteReason,
+            emptyMessage,
+            responseId: response?.id,
+        };
+    }
+    contextBudget(maxTokens) {
+        return (maxTokens ?? max_context_tokens) - context_overhead_margin;
+    }
+    contextOverBudget(items) {
+        return estimateTokens(items) > this.contextBudget();
+    }
+    async compactHistory(inputItems, maxTokens) {
+        if (estimateTokens(inputItems) <= this.contextBudget(maxTokens))
+            return null;
+        const userIndices = inputItems
+            .map((it, i) => ({ it, i }))
+            .filter(({ it }) => it["role"] === "user" && !it["compaction_summary"])
+            .map(({ i }) => i);
+        if (userIndices.length <= compact_keep_recent_turns)
+            return null;
+        const cut = userIndices[userIndices.length - compact_keep_recent_turns];
+        const oldItems = inputItems.slice(0, cut);
+        const recentItems = inputItems.slice(cut);
+        let transcript = oldItems
+            .map((item) => `${item["role"] ?? item["type"] ?? "event"}: ${JSON.stringify(item).slice(0, 2000)}`)
+            .join("\n");
+        if (transcript.length > max_summary_source_chars) {
+            const head = Math.floor(max_summary_source_chars / 2);
+            const tail = max_summary_source_chars - head;
+            transcript =
+                transcript.slice(0, head) +
+                    "\n… (middle of transcript omitted for summarization) …\n" +
+                    transcript.slice(-tail);
+        }
+        const summaryPrompt = "Summarize the coding session transcript below into a compact briefing for " +
+            "continuing the task. Preserve: the user's goals/requests, files read or " +
+            "modified and their current state, commands run and their outcomes, and any " +
+            "unresolved errors or next steps. Omit tool call mechanics and raw output. " +
+            "Be dense, not narrative.\n\n" +
+            transcript;
+        let summary;
+        try {
+            const resp = await this.client.responses.create({
+                model: this.modelName,
+                instructions: "You are a precise summarization assistant for a coding session transcript.",
+                input: [{ role: "user", content: summaryPrompt }],
+                max_output_tokens: 2048,
+            });
+            summary = (resp.output_text || "").trim() || "(summary was empty)";
+        }
+        catch (err) {
+            summary = `(summary unavailable: ${err}; ${oldItems.length} earlier items dropped)`;
+        }
+        const summaryItem = {
+            role: "user",
+            content: `[Summary of earlier conversation]\n${summary}`,
+            compaction_summary: true,
+        };
+        return [summaryItem, ...recentItems];
+    }
+    async compactIfNeeded(conversation, inputItems, story) {
+        if (!this.contextOverBudget(conversation))
+            return [conversation, false];
+        const started = Date.now();
+        const comp = new Status("Compacting conversation for `0s`");
+        comp.start();
+        let compacted;
+        try {
+            compacted = await this.compactHistory(conversation);
+        }
+        finally {
+            comp.stop();
+        }
+        if (!compacted)
+            return [conversation, false];
+        persistCompactionSummary(inputItems, compacted[0]);
+        const text = `Compacted conversation in ${tickDuration((Date.now() - started) / 1000)}`;
+        story.push({ type: "compacted", text });
+        process.stdout.write("\n" + mutedMarkdown(text) + "\n");
+        return [compacted, true];
+    }
+    async executeQuery(userPrompt, inputItems, story, pasteSpans) {
+        this.inQuery = true;
+        inputItems.push({
+            role: "user",
+            content: userPrompt,
+            paste_spans: pasteSpans ? [...pasteSpans] : [],
+        });
+        story.push({ type: "user", text: userPrompt, paste_spans: pasteSpans ?? [] });
+        let conversation = [...inputItems];
+        [conversation] = await this.compactIfNeeded(conversation, inputItems, story);
+        let emptyRetries = 0;
+        const retryPrompts = [];
+        const stats = { thinking: 0, tokens: 0, reasoning: 0, input: 0 };
+        const queryStart = Date.now();
+        const footerText = () => `(Thought for ${tickDuration(stats["thinking"])} · Worked for ${tickDuration((Date.now() - queryStart) / 1000)} · Used \`${stats["tokens"].toLocaleString()}\` tokens)`;
+        const summary = () => mutedMarkdown(footerText());
+        const attachFooter = (items) => {
+            const footer = footerText();
+            for (let i = items.length - 1; i >= 0; i--) {
+                if (items[i]["type"] === "message") {
+                    items[i]["footer"] = footer;
+                    return;
+                }
+            }
+        };
+        const dropRetryPrompts = (conv, input, retries) => {
+            if (!retries.length)
+                return;
+            const remove = new Set(retries.map((rp) => rp));
+            conv.splice(0, conv.length, ...conv.filter((x) => !remove.has(x)));
+            input.splice(0, input.length, ...input.filter((x) => !remove.has(x)));
+            retries.length = 0;
+        };
+        let prevId = null;
+        let pending = conversation;
+        let resetInQuery = true;
+        try {
+            for (let step = 0; step < max_agent_steps; step++) {
+                let text = "";
+                let calls = [];
+                let outputItems = [];
+                let incompleteReason = null;
+                let emptyMessage = null;
+                let respId = "";
+                try {
+                    const res = await this.streamOnce(pending, stats, story, prevId);
+                    text = res.text;
+                    calls = res.calls;
+                    outputItems = res.outputItems;
+                    incompleteReason = res.incompleteReason;
+                    emptyMessage = res.emptyMessage;
+                    respId = res.responseId;
+                }
+                catch (err) {
+                    if (prevId !== null) {
+                        prevId = null;
+                        stripOrphanCalls(conversation);
+                        stripOrphanCalls(inputItems);
+                        pending = conversation;
+                        try {
+                            const res = await this.streamOnce(pending, stats, story, null);
+                            text = res.text;
+                            calls = res.calls;
+                            outputItems = res.outputItems;
+                            incompleteReason = res.incompleteReason;
+                            emptyMessage = res.emptyMessage;
+                            respId = res.responseId;
+                        }
+                        catch (err2) {
+                            process.stdout.write("\n");
+                            renderErrorPanel(`API Error: ${err2}`);
+                            return;
+                        }
+                    }
+                    else {
+                        process.stdout.write("\n");
+                        renderErrorPanel(`API Error: ${err}`);
+                        return;
+                    }
+                }
+                prevId = respId;
+                this.storedResponseIds.push(respId);
+                conversation.push(...outputItems);
+                inputItems.push(...outputItems);
+                pending = [];
+                const [newConv, compactedNow] = await this.compactIfNeeded(conversation, inputItems, story);
+                conversation = newConv;
+                if (compactedNow) {
+                    prevId = null;
+                    pending = conversation;
+                }
+                if (emptyMessage !== null) {
+                    if (incompleteReason === "max_output_tokens" && emptyRetries < max_empty_retries) {
+                        emptyRetries++;
+                        const retryPrompt = {
+                            role: "user",
+                            content: "Your previous turn was cut off before producing any reply or " +
+                                "tool call because it ran out of output tokens. Continue now: " +
+                                "either call a tool or give a direct, concise answer, with " +
+                                "minimal intermediate reasoning.",
+                        };
+                        const rp = { ...retryPrompt };
+                        conversation.push(rp);
+                        inputItems.push(rp);
+                        retryPrompts.push(rp);
+                        pending = prevId === null ? conversation : [retryPrompt];
+                        continue;
+                    }
+                    dropRetryPrompts(conversation, inputItems, retryPrompts);
+                    process.stdout.write("\n" + aiMarkdown(emptyMessage) + "\n");
+                    process.stdout.write("\n" + summary() + "\n");
+                    return;
+                }
+                if (!calls.length) {
+                    process.stdout.write("\n" + summary() + "\n");
+                    story.push({ type: "footer", text: footerText() });
+                    attachFooter(conversation);
+                    attachFooter(inputItems);
+                    return;
+                }
+                if (text.trim())
+                    process.stdout.write("\n");
+                for (const c of calls) {
+                    const started = formatToolAction(c.name, c.arguments, "started");
+                    process.stdout.write(`\x1b[2m${started}\x1b[0m\n`);
+                    if (c.name === "edit_file" || c.name === "write_file")
+                        process.stdout.write("\n");
+                    const rawResult = await this.runTool(c.name, c.arguments);
+                    const failed = toolOutputFailed(c.name, rawResult);
+                    const action = formatToolAction(c.name, c.arguments, failed ? "failed" : "ok");
+                    story.push({ type: "tool", started, text: action, status: failed ? "failed" : "ok" });
+                    const style = failed ? "\x1b[31m" : "\x1b[32m";
+                    process.stdout.write(`${style}${action}\x1b[0m\n\n`);
+                    const truncatedResult = c.name === "read_file"
+                        ? truncateToolOutput(rawResult, max_read_file_stored_chars)
+                        : truncateToolOutput(rawResult);
+                    const outputItem = {
+                        type: "function_call_output",
+                        call_id: c.id,
+                        output: truncatedResult,
+                    };
+                    conversation.push(outputItem);
+                    inputItems.push(outputItem);
+                    if (pending !== conversation)
+                        pending.push(outputItem);
+                }
+            }
+            process.stdout.write("\n\x1b[1;33m⚠ Max tool-call iterations reached for this turn.\x1b[0m\n" +
+                "\x1b[33mThe work so far is saved. If you want the agent to keep going, type " +
+                "[bold]continue[/bold] and the next step will resume from where it left off.\x1b[0m\n");
+            if (retryPrompts.length)
+                dropRetryPrompts(conversation, inputItems, retryPrompts);
+            stripOrphanCalls(conversation);
+            stripOrphanCalls(inputItems);
+        }
+        catch (err) {
+            if (err?.message === "interrupt" || err?.message === "eof") {
+                throw err;
+            }
+            process.stdout.write("\n");
+            renderErrorPanel(`Runtime Exception: ${err}`);
+        }
+        finally {
+            this.inQuery = false;
+            if (stats["tokens"] > 0 && this.keyData) {
+                const userId = this.keyData["user_id"];
+                if (userId) {
+                    reportUsage({
+                        user_id: String(userId),
+                        api_key_id: this.keyData["id"],
+                        model: this.modelName,
+                        input_tokens: stats["input"],
+                        output_tokens: stats["tokens"],
+                        request_count: 1,
+                    });
+                }
+            }
+        }
+    }
+}
+function renderErrorPanel(msg) {
+    const text = msg.replace(/\[bold yellow\]|\[yellow\]|\[\/.*?\]/g, "");
+    process.stdout.write(`\x1b[31m${text}\x1b[0m\n`);
+}
+export { renderErrorPanel };

package/dist/oxe.js

@@ -0,0 +1,6 @@
+import { main } from "./cli.js";
+export { main };
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/sessions.js

@@ -0,0 +1,146 @@
+import fs from "node:fs";
+import path from "node:path";
+import { SESSION_DIR, compact_keep_recent_turns } from "./config.js";
+import { collapseLabelText, messageText } from "./ui.js";
+export const COMMAND_HELP = [
+    ["/help", "Show this list of commands"],
+    ["/resume", "List saved conversations"],
+    ["/resume <n>", "Resume conversation number n"],
+    ["/effort <level>", "Set reasoning effort: none, low, or high"],
+    ["/clear", "Save the current conversation and start a new one"],
+    ["/exit, /quit", "Save the current conversation and exit"],
+];
+function ensureSessionDir() {
+    fs.mkdirSync(SESSION_DIR, { recursive: true });
+}
+function sessionFile(sid) {
+    return path.join(SESSION_DIR, `${String(sid).padStart(6, "0")}.json`);
+}
+export function nextSessionId() {
+    ensureSessionDir();
+    let highest = 0;
+    for (const f of fs.readdirSync(SESSION_DIR)) {
+        if (!f.endsWith(".json"))
+            continue;
+        const stem = f.slice(0, -5);
+        const n = parseInt(stem, 10);
+        if (!Number.isNaN(n) && n > highest)
+            highest = n;
+    }
+    return highest + 1;
+}
+export function saveSession(record) {
+    ensureSessionDir();
+    const target = sessionFile(record["id"]);
+    const tmp = target + ".tmp";
+    const data = JSON.stringify(record, null, 2);
+    try {
+        fs.writeFileSync(tmp, data, "utf-8");
+        fs.renameSync(tmp, target);
+    }
+    catch {
+        try {
+            fs.writeFileSync(target, data, "utf-8");
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export function loadSession(sid) {
+    const p = sessionFile(sid);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const rec = JSON.parse(fs.readFileSync(p, "utf-8"));
+        return rec && typeof rec === "object" ? rec : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function listSessions() {
+    ensureSessionDir();
+    const recs = [];
+    for (const f of fs.readdirSync(SESSION_DIR)) {
+        if (!f.endsWith(".json"))
+            continue;
+        try {
+            const rec = JSON.parse(fs.readFileSync(path.join(SESSION_DIR, f), "utf-8"));
+            if (rec && typeof rec === "object" && Array.isArray(rec["input_items"])) {
+                recs.push(rec);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    recs.sort((a, b) => String(b["updated_at"] ?? "").localeCompare(String(a["updated_at"] ?? "")));
+    return recs;
+}
+export function conversationLabel(inputItems, limit = 80) {
+    let text = null;
+    let spans = null;
+    for (const item of inputItems) {
+        if (item && item["role"] === "user" && !item["compaction_summary"]) {
+            const content = item["content"];
+            if (typeof content === "string" && content.trim()) {
+                text = content.trim();
+            }
+            else if (Array.isArray(content)) {
+                const t = messageText(item);
+                if (t.trim())
+                    text = t.trim();
+            }
+            if (text !== null) {
+                spans = item["paste_spans"] || null;
+                break;
+            }
+        }
+    }
+    if (text === null)
+        return "(conversation)";
+    const label = collapseLabelText(text, spans);
+    return label.split(/\s+/).join(" ").slice(0, limit);
+}
+export function persistCompactionSummary(items, summaryItem) {
+    if (!summaryItem || typeof summaryItem !== "object")
+        return;
+    const idxs = items
+        .map((it, i) => ({ it, i }))
+        .filter(({ it }) => it["role"] === "user" && !it["compaction_summary"])
+        .map(({ i }) => i);
+    let pos;
+    if (compact_keep_recent_turns > 0 && idxs.length > compact_keep_recent_turns) {
+        pos = idxs[idxs.length - compact_keep_recent_turns];
+    }
+    else {
+        pos = items.length;
+    }
+    const existing = new Set(items.map((it) => JSON.stringify(it)));
+    const blob = JSON.stringify(summaryItem);
+    if (existing.has(blob))
+        return;
+    items.splice(pos, 0, summaryItem);
+}
+export function stripOrphanCalls(items) {
+    const callIds = new Set(items.filter((it) => it["type"] === "function_call").map((it) => it["call_id"]));
+    const outIds = new Set(items
+        .filter((it) => it["type"] === "function_call_output")
+        .map((it) => it["call_id"]));
+    const kept = items.filter((it) => !(it["type"] === "function_call" && !outIds.has(it["call_id"])) &&
+        !(it["type"] === "function_call_output" && !callIds.has(it["call_id"])));
+    items.length = 0;
+    items.push(...kept);
+}
+export function toolOutputFailed(name, rawResult) {
+    rawResult = rawResult || "";
+    if (rawResult.startsWith("Error:"))
+        return true;
+    if (name === "bash") {
+        const m = rawResult.match(/exit code: (\d+)/);
+        if (m && parseInt(m[1], 10) !== 0)
+            return true;
+    }
+    return false;
+}