@kiipu/cli 0.0.6 → 0.0.8

package/dist/lib/ask-client.js

@@ -0,0 +1,276 @@
+import { TextDecoder } from 'node:util';
+function isRecord(input) {
+    return typeof input === 'object' && input !== null;
+}
+function buildError(message, code = 'request_failed') {
+    return {
+        ok: false,
+        error: {
+            code,
+            message,
+        },
+    };
+}
+function getErrorMessage(payload, fallback) {
+    if (!isRecord(payload)) {
+        return fallback;
+    }
+    if (typeof payload.message === 'string') {
+        return payload.message;
+    }
+    if (isRecord(payload.message) && typeof payload.message.message === 'string') {
+        return payload.message.message;
+    }
+    if (isRecord(payload.error) && typeof payload.error.message === 'string') {
+        return payload.error.message;
+    }
+    return fallback;
+}
+function getErrorCode(payload, fallback = 'request_failed') {
+    if (!isRecord(payload)) {
+        return fallback;
+    }
+    if (typeof payload.code === 'string') {
+        return payload.code;
+    }
+    if (isRecord(payload.message) && typeof payload.message.code === 'string') {
+        return payload.message.code;
+    }
+    if (isRecord(payload.error) && typeof payload.error.code === 'string') {
+        return payload.error.code;
+    }
+    return fallback;
+}
+function parseSource(input) {
+    if (!isRecord(input)) {
+        return null;
+    }
+    const postId = typeof input.postId === 'string' ? input.postId : '';
+    const snippet = typeof input.snippet === 'string' ? input.snippet : '';
+    if (!postId || !snippet) {
+        return null;
+    }
+    return {
+        index: typeof input.index === 'number' ? input.index : 0,
+        postId,
+        title: typeof input.title === 'string' ? input.title : null,
+        snippet,
+        score: typeof input.score === 'number' ? input.score : 0,
+        createdAt: typeof input.createdAt === 'string' ? input.createdAt : undefined,
+    };
+}
+function parseSources(input) {
+    return Array.isArray(input) ? input.map(parseSource).filter((source) => Boolean(source)) : [];
+}
+function parseAskEvent(input) {
+    if (!isRecord(input) || typeof input.type !== 'string') {
+        return null;
+    }
+    switch (input.type) {
+        case 'meta':
+            if (typeof input.conversationId !== 'string') {
+                return null;
+            }
+            return {
+                type: 'meta',
+                conversationId: input.conversationId,
+                isNew: Boolean(input.isNew),
+                title: typeof input.title === 'string' ? input.title : null,
+            };
+        case 'sources':
+            return {
+                type: 'sources',
+                sources: parseSources(input.sources),
+                locked: Boolean(input.locked),
+                retrievalMode: input.retrievalMode === 'semantic' || input.retrievalMode === 'temporal_list'
+                    ? input.retrievalMode
+                    : undefined,
+                totalCount: typeof input.totalCount === 'number' ? input.totalCount : undefined,
+                truncated: typeof input.truncated === 'boolean' ? input.truncated : undefined,
+            };
+        case 'delta':
+            return typeof input.text === 'string' ? { type: 'delta', text: input.text } : null;
+        case 'done':
+            if (typeof input.turnId !== 'string') {
+                return null;
+            }
+            return {
+                type: 'done',
+                turnId: input.turnId,
+                inputTokens: typeof input.inputTokens === 'number' ? input.inputTokens : 0,
+                outputTokens: typeof input.outputTokens === 'number' ? input.outputTokens : 0,
+                latencyMs: typeof input.latencyMs === 'number' ? input.latencyMs : 0,
+            };
+        case 'title':
+            if (typeof input.conversationId !== 'string' || typeof input.title !== 'string') {
+                return null;
+            }
+            return { type: 'title', conversationId: input.conversationId, title: input.title };
+        case 'error':
+            return {
+                type: 'error',
+                code: typeof input.code === 'string' ? input.code : 'unknown',
+                message: typeof input.message === 'string' ? input.message : 'Unknown Ask error.',
+            };
+        default:
+            return null;
+    }
+}
+function extractDataField(frame) {
+    const dataLines = [];
+    for (const line of frame.split('\n')) {
+        const normalized = line.endsWith('\r') ? line.slice(0, -1) : line;
+        if (normalized.startsWith('data:')) {
+            dataLines.push(normalized.slice(5).replace(/^ /, ''));
+        }
+    }
+    return dataLines.length > 0 ? dataLines.join('\n') : null;
+}
+async function readJson(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+export class KiipuAskClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async requestJson(path, init) {
+        let response;
+        try {
+            response = await fetch(`${this.config.apiBaseUrl}${path}`, {
+                ...init,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                    ...(init.headers ?? {}),
+                },
+            });
+        }
+        catch {
+            return buildError(`Kiipu API is unreachable at ${this.config.apiBaseUrl}.`, 'api_unreachable');
+        }
+        const payload = await readJson(response);
+        if (!response.ok) {
+            return buildError(getErrorMessage(payload, `Request failed with ${response.status}.`), getErrorCode(payload, `http_${response.status}`));
+        }
+        const data = isRecord(payload) && 'data' in payload ? payload.data : payload;
+        return {
+            ok: true,
+            data: data,
+        };
+    }
+    listConversations(input) {
+        const search = new URLSearchParams();
+        if (input.query) {
+            search.set('q', input.query);
+        }
+        if (input.limit) {
+            search.set('limit', String(input.limit));
+        }
+        if (input.archived) {
+            search.set('view', 'archived');
+        }
+        const query = search.toString();
+        return this.requestJson(`/ai/conversations${query ? `?${query}` : ''}`, { method: 'GET' });
+    }
+    getConversation(id) {
+        return this.requestJson(`/ai/conversations/${encodeURIComponent(id)}`, {
+            method: 'GET',
+        });
+    }
+    async *streamMessage(input) {
+        const body = {
+            question: input.question,
+            ...(input.topK ? { topK: input.topK } : {}),
+            ...(input.sourceMode ? { sourceMode: input.sourceMode } : {}),
+        };
+        let response;
+        try {
+            response = await fetch(`${this.config.apiBaseUrl}/ai/conversations/${encodeURIComponent(input.conversationId)}/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                    Accept: 'text/event-stream',
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (error) {
+            yield {
+                type: 'error',
+                code: 'network_error',
+                message: error instanceof Error ? error.message : 'Network request failed.',
+            };
+            return;
+        }
+        if (!response.ok || !response.body) {
+            const payload = await readJson(response);
+            yield {
+                type: 'error',
+                code: getErrorCode(payload, `http_${response.status}`),
+                message: getErrorMessage(payload, `Request failed with ${response.status}.`),
+            };
+            return;
+        }
+        let settled = false;
+        const decoder = new TextDecoder();
+        const reader = response.body.getReader();
+        let buffer = '';
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                let separator = buffer.indexOf('\n\n');
+                while (separator !== -1) {
+                    const frame = buffer.slice(0, separator);
+                    buffer = buffer.slice(separator + 2);
+                    const data = extractDataField(frame);
+                    if (data && data !== '[DONE]') {
+                        try {
+                            const event = parseAskEvent(JSON.parse(data));
+                            if (event) {
+                                if (event.type === 'done' || event.type === 'error') {
+                                    settled = true;
+                                }
+                                yield event;
+                            }
+                        }
+                        catch {
+                            // Ignore malformed SSE frames from intermediaries.
+                        }
+                    }
+                    separator = buffer.indexOf('\n\n');
+                }
+            }
+        }
+        catch (error) {
+            if (!settled) {
+                yield {
+                    type: 'error',
+                    code: 'stream_error',
+                    message: error instanceof Error ? error.message : 'Stream interrupted.',
+                };
+            }
+            return;
+        }
+        finally {
+            reader.releaseLock();
+        }
+        if (!settled) {
+            yield {
+                type: 'error',
+                code: 'stream_truncated',
+                message: 'The response ended unexpectedly. Please try again.',
+            };
+        }
+    }
+}

package/dist/lib/ask-formatters.js

@@ -0,0 +1,114 @@
+function formatTimestamp(value) {
+    if (!value) {
+        return 'unknown time';
+    }
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        return value;
+    }
+    return parsed.toLocaleString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}
+function truncate(value, maxLength) {
+    const normalized = value.trim().replace(/\s+/g, ' ');
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength - 3)}...`;
+}
+function formatSourceLine(source) {
+    const title = source.title?.trim() || '(untitled)';
+    const score = Number.isFinite(source.score) ? ` score ${source.score.toFixed(3)}` : '';
+    return `[${source.index}] ${title} (${source.postId})${score}`;
+}
+export function formatAskFooter(input) {
+    const lines = ['', 'Sources:'];
+    if (input.sources.length === 0) {
+        lines.push('  none');
+    }
+    else {
+        for (const source of input.sources) {
+            lines.push(`  ${formatSourceLine(source)}`);
+            lines.push(`    ${truncate(source.snippet, 140)}`);
+        }
+    }
+    const usage = input.usage;
+    if (usage) {
+        lines.push('', `Usage: input ${usage.inputTokens}, output ${usage.outputTokens}, latency ${usage.latencyMs}ms`);
+    }
+    if (input.conversationId) {
+        lines.push(`Conversation: ${input.conversationId}`);
+    }
+    if (input.title) {
+        lines.push(`Title: ${input.title}`);
+    }
+    if (input.turnId) {
+        lines.push(`Turn: ${input.turnId}`);
+    }
+    return lines.join('\n');
+}
+export function formatConversationHistory(title, conversations, nextCursor) {
+    const lines = [title, ''];
+    if (conversations.length === 0) {
+        lines.push('No Ask conversations found.');
+        return lines.join('\n');
+    }
+    for (const item of conversations) {
+        const label = item.title?.trim() || truncate(item.preview, 80) || '(untitled)';
+        const flags = [item.pinnedAt ? 'pinned' : '', item.archivedAt ? 'archived' : '']
+            .filter(Boolean)
+            .join(', ');
+        lines.push(`${item.id}  ${formatTimestamp(item.lastMessageAt)}`);
+        lines.push(`  ${label}`);
+        if (flags) {
+            lines.push(`  flags: ${flags}`);
+        }
+        lines.push('');
+    }
+    if (nextCursor) {
+        lines.push(`Next cursor: ${nextCursor}`);
+    }
+    if (!nextCursor && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines.join('\n');
+}
+function formatTurn(turn) {
+    const role = turn.role === 'user' ? 'User' : 'Assistant';
+    const lines = [`${role} ${turn.id}  ${formatTimestamp(turn.createdAt)}  status: ${turn.status}`];
+    if (turn.errorCode) {
+        lines.push(`error: ${turn.errorCode}`);
+    }
+    lines.push(turn.content.trim() || '(empty)');
+    if (turn.sources && turn.sources.length > 0) {
+        lines.push('sources:');
+        for (const source of turn.sources) {
+            lines.push(`  ${formatSourceLine(source)}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatConversationDetail(detail) {
+    const lines = [
+        detail.title?.trim() || '(untitled Ask conversation)',
+        '',
+        `id: ${detail.id}`,
+        `created: ${formatTimestamp(detail.createdAt)}`,
+        `updated: ${formatTimestamp(detail.lastMessageAt)}`,
+        '',
+    ];
+    if (detail.turns.length === 0) {
+        lines.push('No turns found.');
+    }
+    else {
+        for (const turn of detail.turns) {
+            lines.push(formatTurn(turn), '');
+        }
+    }
+    return lines.slice(0, -1).join('\n');
+}

package/dist/lib/kiipu-user-client.js

@@ -12,6 +12,19 @@ export class KiipuUserApiClient {
     constructor(config) {
         this.config = config;
     }
+    buildPath(path, params) {
+        if (!params) {
+            return path;
+        }
+        const search = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (typeof value === 'string' && value.length > 0) {
+                search.set(key, value);
+            }
+        }
+        const query = search.toString();
+        return query ? `${path}?${query}` : path;
+    }
     async request(path, init) {
         let response;
         try {
@@ -59,4 +72,35 @@ export class KiipuUserApiClient {
             body: JSON.stringify(input),
         });
     }
+    listPosts(input) {
+        return this.request(this.buildPath('/posts/me', input));
+    }
+    searchPosts(query) {
+        return this.request(this.buildPath('/posts/me/search', { q: query }));
+    }
+    listStarredPosts(input) {
+        return this.request(this.buildPath('/posts/me/starred', input));
+    }
+    listDeletedPosts(input) {
+        return this.request(this.buildPath('/posts/me/deleted', input));
+    }
+    getPost(id) {
+        return this.request(`/posts/${id}`);
+    }
+    updatePost(id, input) {
+        return this.request(`/posts/${id}/content`, {
+            method: 'PATCH',
+            body: JSON.stringify(input),
+        });
+    }
+    toggleStar(id) {
+        return this.request(`/posts/${id}/star`, {
+            method: 'PATCH',
+        });
+    }
+    togglePin(id) {
+        return this.request(`/posts/${id}/pin`, {
+            method: 'PATCH',
+        });
+    }
 }

package/dist/lib/post-formatters.js

@@ -0,0 +1,74 @@
+function formatTimestamp(value) {
+    if (!value) {
+        return 'unknown time';
+    }
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        return value;
+    }
+    return parsed.toLocaleString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}
+function formatTags(tags, limit) {
+    const normalized = Array.isArray(tags)
+        ? tags
+            .map((tag) => tag.tagName?.trim())
+            .filter((tag) => Boolean(tag))
+            .slice(0, limit)
+        : [];
+    return normalized.length > 0 ? normalized.map((tag) => `#${tag}`).join(', ') : 'none';
+}
+function getPostPreview(post) {
+    const content = (post.title?.trim() || post.finalText?.trim() || post.rawText?.trim() || '').replace(/\s+/g, ' ');
+    if (!content) {
+        return '(empty)';
+    }
+    return content.length > 100 ? `${content.slice(0, 97)}...` : content;
+}
+function getStatusFlags(post) {
+    const flags = [];
+    if (post.isPinned) {
+        flags.push('pinned');
+    }
+    if (post.isStarred) {
+        flags.push('starred');
+    }
+    return flags.length > 0 ? flags.join(', ') : 'none';
+}
+export function formatPostCollection(title, posts) {
+    const lines = [title, ''];
+    if (posts.length === 0) {
+        lines.push('No posts found.');
+        return lines.join('\n');
+    }
+    for (const post of posts) {
+        lines.push(`${post.id}  ${formatTimestamp(post.updatedAt ?? post.createdAt)}`);
+        lines.push(`  flags: ${getStatusFlags(post)}  visibility: ${post.visibility}  tags: ${formatTags(post.tags, 3)}`);
+        lines.push(`  ${getPostPreview(post)}`);
+        lines.push('');
+    }
+    return lines.slice(0, -1).join('\n');
+}
+export function formatPostDetail(post) {
+    const title = post.title?.trim() || '(untitled)';
+    const body = post.finalText?.trim() || post.rawText?.trim() || '(empty)';
+    return [
+        title,
+        '',
+        body,
+        '',
+        `id: ${post.id}`,
+        `visibility: ${post.visibility}`,
+        `created: ${formatTimestamp(post.createdAt)}`,
+        `updated: ${formatTimestamp(post.updatedAt)}`,
+        `tags: ${formatTags(post.tags)}`,
+        `folder: ${post.folder ? `${post.folder.name} (${post.folder.id})` : 'none'}`,
+        `pinned: ${post.isPinned ? 'yes' : 'no'}`,
+        `starred: ${post.isStarred ? 'yes' : 'no'}`,
+    ].join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kiipu/cli",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Kiipu CLI for local authentication, doctor checks, and direct post actions.",
   "license": "MIT",
   "type": "module",