dominds 0.1.0

package/dist/tellask.js

@@ -0,0 +1,431 @@
+"use strict";
+/**
+ * # Tellask Grammar ("诉请")
+ *
+ * A primitive, line-based streaming call format designed to be robust under arbitrary
+ * upstream chunk boundaries (no backtick/markdown state machine required).
+ *
+ * ## Rules
+ *
+ * - Tellask call blocks consist of **lines**.
+ * - Any line starting with literal `!?` is a tellask line (prefix is not included in payload).
+ * - Any line(s) **without** `!?` prefix are treated as markdown, and also act as separators:
+ *   they terminate the current tellask call block (if any).
+ *
+ * Within a tellask call block:
+ * - The first tellask line is the start of the call headline.
+ * - The first line MUST start with `!?@<valid-mention-id>` to be considered valid.
+ *   Otherwise the block still parses, but is reported as malformed.
+ * - While still in headline phase, subsequent tellask lines starting with `!?@` extend
+ *   the headline (multiline headline).
+ * - Any other tellask lines (starting with `!?` but NOT `!?@`) start/continue the call body.
+ *
+ * All downstream chunks preserve upstream chunk boundaries unless correctness requires
+ * a split (e.g. line-start prefix disambiguation across chunks).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TellaskStreamParser = void 0;
+const id_1 = require("./utils/id");
+class TellaskStreamParser {
+    constructor(downstream) {
+        this.callCounter = 0;
+        this.collectedCalls = [];
+        this.markdownStarted = false;
+        this.markdownChunkBuffer = '';
+        this.activeCall = null;
+        this.headlineBuffer = '';
+        this.bodyBuffer = '';
+        this.isAtLineStart = true;
+        this.lineStartProbe = '';
+        this.currentLineKind = 'unknown';
+        this.pendingCallLineRole = false;
+        this.currentCallLineRole = null;
+        this.downstream = downstream;
+    }
+    async takeUpstreamChunk(chunk) {
+        let pos = 0;
+        while (pos < chunk.length) {
+            const char = chunk[pos] ?? '';
+            if (this.isAtLineStart && this.currentLineKind === 'unknown') {
+                const consumed = await this.processLineStartProbe(char);
+                if (consumed) {
+                    pos += 1;
+                    continue;
+                }
+                // Not consumed means we decided the line kind and need to re-process this char
+                // with the decided line kind.
+            }
+            if (this.currentLineKind === 'markdown') {
+                await this.processMarkdownChar(char);
+                pos += 1;
+                continue;
+            }
+            if (this.currentLineKind === 'call') {
+                await this.processCallChar(char);
+                pos += 1;
+                continue;
+            }
+            // Fallback: should be unreachable, but keep safe to avoid infinite loops.
+            await this.processMarkdownChar(char);
+            pos += 1;
+        }
+        await this.flushAtUpstreamChunkEnd();
+    }
+    async finalize() {
+        // Resolve any pending single-char probe at start-of-line.
+        if (this.isAtLineStart && this.currentLineKind === 'unknown' && this.lineStartProbe === '!') {
+            // This is a markdown separator line starting with '!' but not enough chars to be `!?`.
+            await this.endActiveCallBlockIfAny();
+            this.markdownChunkBuffer += '!';
+            this.lineStartProbe = '';
+        }
+        // End-of-input can terminate a call without a trailing newline.
+        if (this.activeCall) {
+            await this.resolvePendingFirstLineMentionAtEofIfNeeded();
+            await this.endActiveCallBlockIfAny();
+        }
+        if (this.markdownChunkBuffer.length > 0) {
+            if (!this.markdownStarted) {
+                await this.downstream.markdownStart();
+                this.markdownStarted = true;
+            }
+            await this.downstream.markdownChunk(this.markdownChunkBuffer);
+            this.markdownChunkBuffer = '';
+        }
+        if (this.markdownStarted) {
+            await this.downstream.markdownFinish();
+            this.markdownStarted = false;
+        }
+    }
+    getCollectedCalls() {
+        return [...this.collectedCalls];
+    }
+    async processLineStartProbe(char) {
+        // Returns true if the character was consumed as part of probing decision.
+        if (this.lineStartProbe === '') {
+            if (char === '\n') {
+                // Empty line is markdown separator.
+                await this.endActiveCallBlockIfAny();
+                this.currentLineKind = 'markdown';
+                await this.processMarkdownChar(char);
+                this.resetLineStateAfterNewline();
+                return true;
+            }
+            this.lineStartProbe = '!';
+            if (char !== '!') {
+                // First char isn't '!' => markdown line.
+                this.lineStartProbe = '';
+                await this.endActiveCallBlockIfAny();
+                this.currentLineKind = 'markdown';
+                // Re-process this char as markdown.
+                return false;
+            }
+            // We saw '!' at column 0; need one more char to decide.
+            return true;
+        }
+        // lineStartProbe === '!' means we already consumed a '!' at strict column 0.
+        if (char === '\n') {
+            // Line length is 1 => markdown line containing '!\n'.
+            this.lineStartProbe = '';
+            await this.endActiveCallBlockIfAny();
+            this.currentLineKind = 'markdown';
+            this.markdownChunkBuffer += '!\n';
+            this.resetLineStateAfterNewline();
+            return true;
+        }
+        if (char === '?') {
+            // Confirmed call line prefix `!?` at column 0.
+            this.lineStartProbe = '';
+            await this.ensureCallLineModeStart();
+            return true;
+        }
+        // Not `!?` => markdown line starting with '!' then current char.
+        this.lineStartProbe = '';
+        await this.endActiveCallBlockIfAny();
+        this.currentLineKind = 'markdown';
+        this.markdownChunkBuffer += '!' + char;
+        this.isAtLineStart = false;
+        return true;
+    }
+    async ensureCallLineModeStart() {
+        // Transition from markdown to call line: finalize markdown fragment if active.
+        if (this.markdownChunkBuffer.length > 0) {
+            if (!this.markdownStarted) {
+                await this.downstream.markdownStart();
+                this.markdownStarted = true;
+            }
+            await this.downstream.markdownChunk(this.markdownChunkBuffer);
+            this.markdownChunkBuffer = '';
+        }
+        if (this.markdownStarted) {
+            await this.downstream.markdownFinish();
+            this.markdownStarted = false;
+        }
+        this.currentLineKind = 'call';
+        this.isAtLineStart = false;
+        this.pendingCallLineRole = true;
+        this.currentCallLineRole = null;
+        if (!this.activeCall) {
+            this.activeCall = {
+                kind: 'active',
+                validation: null,
+                firstLineMentionParse: { kind: 'pending_first_char' },
+                headLine: '',
+                body: '',
+                callLineIndex: 0,
+                phase: 'headline',
+                headLineFinished: false,
+                bodyStarted: false,
+                callStartEmitted: false,
+            };
+        }
+        else {
+            this.activeCall.callLineIndex += 1;
+        }
+    }
+    async processMarkdownChar(char) {
+        // Markdown content includes all characters verbatim.
+        this.markdownChunkBuffer += char;
+        if (char === '\n') {
+            this.resetLineStateAfterNewline();
+        }
+        else {
+            this.isAtLineStart = false;
+        }
+    }
+    async processCallChar(char) {
+        const call = this.activeCall;
+        if (!call) {
+            // Should never happen: call line implies active call. Fall back to markdown.
+            await this.processMarkdownChar(char);
+            return;
+        }
+        if (this.pendingCallLineRole) {
+            const role = this.decideCallLineRole(call, char);
+            this.pendingCallLineRole = false;
+            this.currentCallLineRole = role;
+            if (role === 'body') {
+                if (call.phase === 'headline') {
+                    await this.finishHeadlineIfNeeded();
+                    await this.startBodyIfNeeded();
+                    call.phase = 'body';
+                }
+            }
+        }
+        // First line mention validation is based on the first tellask line only.
+        if (call.callLineIndex === 0 && call.phase === 'headline') {
+            await this.processFirstLineMentionParse(char);
+        }
+        if (this.currentCallLineRole === 'headline') {
+            this.headlineBuffer += char;
+        }
+        else {
+            this.bodyBuffer += char;
+        }
+        if (char === '\n') {
+            this.resetLineStateAfterNewline();
+        }
+        else {
+            this.isAtLineStart = false;
+        }
+    }
+    decideCallLineRole(call, firstCharAfterPrefix) {
+        if (call.phase === 'body')
+            return 'body';
+        if (call.callLineIndex === 0)
+            return 'headline';
+        return firstCharAfterPrefix === '@' ? 'headline' : 'body';
+    }
+    async processFirstLineMentionParse(char) {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        const parse = call.firstLineMentionParse;
+        if (parse.kind === 'resolved')
+            return;
+        if (parse.kind === 'pending_first_char') {
+            if (char === '\n') {
+                await this.resolveFirstLineMention({ kind: 'malformed', reason: 'missing_mention_prefix' });
+                return;
+            }
+            if (char !== '@') {
+                await this.resolveFirstLineMention({ kind: 'malformed', reason: 'missing_mention_prefix' });
+                return;
+            }
+            call.firstLineMentionParse = { kind: 'pending_mention_chars', raw: '' };
+            return;
+        }
+        if (parse.kind === 'pending_mention_chars') {
+            if (this.isValidMentionChar(char)) {
+                call.firstLineMentionParse = { kind: 'pending_mention_chars', raw: parse.raw + char };
+                return;
+            }
+            const trimmed = this.trimTrailingDots(parse.raw);
+            if (trimmed.length > 0) {
+                await this.resolveFirstLineMention({ kind: 'valid', firstMention: trimmed });
+            }
+            else {
+                await this.resolveFirstLineMention({ kind: 'malformed', reason: 'invalid_mention_id' });
+            }
+            return;
+        }
+    }
+    async resolveFirstLineMention(validation) {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        call.validation = validation;
+        call.firstLineMentionParse = { kind: 'resolved', validation };
+        if (!call.callStartEmitted) {
+            call.callStartEmitted = true;
+            await this.downstream.callStart(validation);
+        }
+        await this.flushHeadlineBuffer();
+    }
+    async resolvePendingFirstLineMentionAtEofIfNeeded() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        if (call.callLineIndex !== 0)
+            return;
+        const parse = call.firstLineMentionParse;
+        if (parse.kind === 'resolved')
+            return;
+        if (parse.kind === 'pending_first_char') {
+            await this.resolveFirstLineMention({ kind: 'malformed', reason: 'missing_mention_prefix' });
+            return;
+        }
+        if (parse.kind === 'pending_mention_chars') {
+            const trimmed = this.trimTrailingDots(parse.raw);
+            if (trimmed.length > 0) {
+                await this.resolveFirstLineMention({ kind: 'valid', firstMention: trimmed });
+            }
+            else {
+                await this.resolveFirstLineMention({ kind: 'malformed', reason: 'invalid_mention_id' });
+            }
+        }
+    }
+    async finishHeadlineIfNeeded() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        if (call.headLineFinished)
+            return;
+        if (!call.callStartEmitted) {
+            // If the first line did not contain a mention terminator, we resolve at boundary.
+            await this.resolvePendingFirstLineMentionAtEofIfNeeded();
+        }
+        await this.flushHeadlineBuffer();
+        await this.downstream.callHeadLineFinish();
+        call.headLineFinished = true;
+    }
+    async startBodyIfNeeded() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        if (call.bodyStarted)
+            return;
+        await this.downstream.callBodyStart();
+        call.bodyStarted = true;
+    }
+    async endActiveCallBlockIfAny() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        // If the first line never encountered an invalid mention delimiter, ensure we still resolve.
+        await this.resolvePendingFirstLineMentionAtEofIfNeeded();
+        await this.finishHeadlineIfNeeded();
+        if (call.bodyStarted) {
+            await this.flushBodyBuffer();
+            await this.downstream.callBodyFinish();
+        }
+        const validation = call.validation ?? { kind: 'malformed', reason: 'missing_mention_prefix' };
+        const callId = (0, id_1.generateContentHash)(`tellask\n${validation.kind === 'valid' ? validation.firstMention : ''}\n${call.headLine}\n${call.body}`, this.callCounter++);
+        this.collectedCalls.push({
+            validation,
+            headLine: call.headLine,
+            body: call.body,
+            callId,
+        });
+        await this.downstream.callFinish(callId);
+        this.activeCall = null;
+        this.headlineBuffer = '';
+        this.bodyBuffer = '';
+        this.pendingCallLineRole = false;
+        this.currentCallLineRole = null;
+    }
+    resetLineStateAfterNewline() {
+        this.isAtLineStart = true;
+        this.lineStartProbe = '';
+        this.currentLineKind = 'unknown';
+        this.pendingCallLineRole = false;
+        this.currentCallLineRole = null;
+    }
+    async flushHeadlineBuffer() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        if (!call.callStartEmitted)
+            return;
+        if (this.headlineBuffer.length === 0)
+            return;
+        call.headLine += this.headlineBuffer;
+        await this.downstream.callHeadLineChunk(this.headlineBuffer);
+        this.headlineBuffer = '';
+    }
+    async flushBodyBuffer() {
+        const call = this.activeCall;
+        if (!call)
+            return;
+        if (this.bodyBuffer.length === 0)
+            return;
+        call.body += this.bodyBuffer;
+        await this.downstream.callBodyChunk(this.bodyBuffer);
+        this.bodyBuffer = '';
+    }
+    async flushAtUpstreamChunkEnd() {
+        if (this.markdownChunkBuffer.length > 0) {
+            if (!this.markdownStarted) {
+                await this.downstream.markdownStart();
+                this.markdownStarted = true;
+            }
+            await this.downstream.markdownChunk(this.markdownChunkBuffer);
+            this.markdownChunkBuffer = '';
+        }
+        const call = this.activeCall;
+        if (call) {
+            if (call.callLineIndex === 0) {
+                const parse = call.firstLineMentionParse;
+                if (parse.kind === 'pending_mention_chars' && parse.raw.length > 0) {
+                    // Do nothing: we cannot resolve until a delimiter/newline/EOF.
+                }
+            }
+            await this.flushHeadlineBuffer();
+            if (call.bodyStarted) {
+                await this.flushBodyBuffer();
+            }
+        }
+    }
+    isValidMentionChar(char) {
+        const charCode = char.charCodeAt(0);
+        return (
+        // ASCII alphanumeric: a-z, A-Z, 0-9
+        (charCode >= 48 && charCode <= 57) ||
+            (charCode >= 65 && charCode <= 90) ||
+            (charCode >= 97 && charCode <= 122) ||
+            // Special allowed characters
+            char === '_' ||
+            char === '-' ||
+            char === '.' ||
+            // Unicode letters and digits
+            /\p{L}/u.test(char) ||
+            /\p{N}/u.test(char));
+    }
+    trimTrailingDots(value) {
+        let out = value;
+        while (out.endsWith('.'))
+            out = out.slice(0, -1);
+        return out;
+    }
+}
+exports.TellaskStreamParser = TellaskStreamParser;

package/dist/tool.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateArgs = validateArgs;
+function validateArgs(schema, args) {
+    if (!isRecord(args)) {
+        return { ok: false, error: 'Arguments must be an object' };
+    }
+    if (Array.isArray(args)) {
+        return { ok: false, error: 'Arguments must be an object' };
+    }
+    const schemaType = isRecord(schema) && 'type' in schema ? schema.type : undefined;
+    if (schemaType !== undefined && schemaType !== 'object') {
+        return { ok: false, error: 'Schema root must be an object' };
+    }
+    const propertiesValue = isRecord(schema) && 'properties' in schema ? schema.properties : undefined;
+    const properties = isRecord(propertiesValue) ? propertiesValue : {};
+    const requiredValue = isRecord(schema) && 'required' in schema ? schema.required : undefined;
+    const required = Array.isArray(requiredValue) && requiredValue.every((v) => typeof v === 'string')
+        ? new Set(requiredValue)
+        : new Set();
+    const additionalPropertiesValue = isRecord(schema) && 'additionalProperties' in schema ? schema.additionalProperties : undefined;
+    const allowAdditional = additionalPropertiesValue === false
+        ? false
+        : additionalPropertiesValue === true || additionalPropertiesValue === undefined
+            ? true
+            : true; // schema additionalProperties is allowed (not deeply validated)
+    // required fields
+    for (const key of required) {
+        if (!(key in args))
+            return { ok: false, error: `Missing required field: ${key}` };
+    }
+    // validate each provided field
+    for (const [key, value] of Object.entries(args)) {
+        const propSchemaUnknown = properties[key];
+        if (propSchemaUnknown === undefined) {
+            if (!allowAdditional) {
+                return { ok: false, error: `Unexpected field: ${key}` };
+            }
+            continue;
+        }
+        const res = validateValue(propSchemaUnknown, value, key);
+        if (!res.ok)
+            return res;
+    }
+    return { ok: true };
+}
+function validateValue(schema, value, path) {
+    if (!isRecord(schema)) {
+        // Unknown schema shape: don't block execution.
+        return { ok: true };
+    }
+    const typeValue = 'type' in schema ? schema.type : undefined;
+    const schemaType = typeof typeValue === 'string'
+        ? typeValue
+        : Array.isArray(typeValue) && typeValue.every((t) => typeof t === 'string')
+            ? typeValue
+            : undefined;
+    if (schemaType === undefined) {
+        // Unknown/omitted type: permissive.
+        return { ok: true };
+    }
+    const acceptsType = (t) => {
+        switch (t) {
+            case 'string':
+                return typeof value === 'string';
+            case 'number':
+                return typeof value === 'number';
+            case 'integer':
+                return typeof value === 'number' && Number.isInteger(value);
+            case 'boolean':
+                return typeof value === 'boolean';
+            case 'null':
+                return value === null;
+            case 'array': {
+                if (!Array.isArray(value))
+                    return false;
+                if (!('items' in schema))
+                    return true;
+                const itemsSchema = schema.items;
+                if (itemsSchema === undefined)
+                    return true;
+                if (Array.isArray(itemsSchema)) {
+                    // Tuple validation: validate corresponding indices when schema exists.
+                    for (let i = 0; i < Math.min(itemsSchema.length, value.length); i++) {
+                        const r = validateValue(itemsSchema[i], value[i], `${path}[${i}]`);
+                        if (!r.ok)
+                            return false;
+                    }
+                    return true;
+                }
+                for (let i = 0; i < value.length; i++) {
+                    const r = validateValue(itemsSchema, value[i], `${path}[${i}]`);
+                    if (!r.ok)
+                        return false;
+                }
+                return true;
+            }
+            case 'object': {
+                if (!isRecord(value) || Array.isArray(value))
+                    return false;
+                const propsValue = 'properties' in schema ? schema.properties : undefined;
+                const props = isRecord(propsValue) ? propsValue : {};
+                const requiredValue = 'required' in schema ? schema.required : undefined;
+                const required = Array.isArray(requiredValue) && requiredValue.every((v) => typeof v === 'string')
+                    ? new Set(requiredValue)
+                    : new Set();
+                const additionalPropertiesValue = 'additionalProperties' in schema ? schema.additionalProperties : undefined;
+                const allowAdditional = additionalPropertiesValue === false
+                    ? false
+                    : additionalPropertiesValue === true || additionalPropertiesValue === undefined
+                        ? true
+                        : true;
+                for (const key of required) {
+                    if (!(key in value)) {
+                        return false;
+                    }
+                }
+                for (const [k, v] of Object.entries(value)) {
+                    const subSchema = props[k];
+                    if (subSchema === undefined) {
+                        if (!allowAdditional)
+                            return false;
+                        continue;
+                    }
+                    const r = validateValue(subSchema, v, `${path}.${k}`);
+                    if (!r.ok)
+                        return false;
+                }
+                return true;
+            }
+            default:
+                return true;
+        }
+    };
+    if (Array.isArray(schemaType)) {
+        for (const t of schemaType) {
+            if (acceptsType(t)) {
+                return { ok: true };
+            }
+        }
+        return { ok: false, error: `Field ${path} does not match expected type` };
+    }
+    if (!acceptsType(schemaType)) {
+        return { ok: false, error: `Field ${path} does not match expected type` };
+    }
+    return { ok: true };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}