@duckcodeailabs/dql-cli 1.0.4 → 1.2.2

package/dist/local-runtime.js

@@ -4,7 +4,9 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, wat
 import { dirname, extname, join, normalize, relative, resolve } from 'node:path';
 import { buildExecutionPlan, createWelcomeNotebook, deserializeNotebook, getConnectorFormSchemas, hasSemanticRefs, resolveSemanticRefs, } from '@duckcodeailabs/dql-notebook';
 import { loadSemanticLayerFromDir, resolveSemanticLayerAsync, Parser, buildLineageGraph, buildManifest, analyzeImpact, buildTrustChain, detectDomainFlows, getDomainTrustOverview, queryLineage, queryCompleteLineagePaths, LineageGraph, canonicalize, canonicalizeNotebook, diffDQL, diffNotebook, } from '@duckcodeailabs/dql-core';
+import { load as loadYaml } from 'js-yaml';
 import { listBlockTemplates } from './block-templates.js';
+import { getRunner as getLLMRunner } from './llm/index.js';
 import { buildSemanticObjectDetail, buildSemanticTree, computeSyncDiff, loadSemanticImportManifest, performSemanticImport, previewSemanticImport, syncSemanticImport, } from './semantic-import.js';
 export async function startLocalServer(opts) {
     const { rootDir, executor, connection: rawConnection, preferredPort, projectRoot = process.cwd() } = opts;
@@ -304,8 +306,11 @@ export async function startLocalServer(opts) {
                 res.end(serializeJSON(merged));
             }
             catch (error) {
-                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
-                res.end(serializeJSON(scanDataFiles(projectRoot)));
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`[dql] /api/schema introspection failed: ${message}`);
+                const fallback = scanDataFiles(projectRoot).map((f) => ({ ...f, source: 'file' }));
+                res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(serializeJSON({ error: message, fallback }));
             }
             return;
         }
@@ -344,7 +349,7 @@ export async function startLocalServer(opts) {
         if (req.method === 'POST' && path === '/api/blocks/save-from-cell') {
             try {
                 const body = await readJSON(req);
-                const { name, domain, owner, content, description, tags, metricRefs, template, } = body;
+                const { name, domain, owner, content, description, tags, metricRefs, template, llmContext, examples, invariants, } = body;
                 if (!name || typeof name !== 'string' || !content || typeof content !== 'string') {
                     res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
                     res.end(serializeJSON({ error: 'name and content are required' }));
@@ -374,6 +379,9 @@ export async function startLocalServer(opts) {
                     tags,
                     metricRefs,
                     template,
+                    llmContext,
+                    examples,
+                    invariants,
                     gitMetadata: readGitMetadata(projectRoot),
                 });
                 res.writeHead(201, { 'Content-Type': 'application/json; charset=utf-8' });
@@ -422,6 +430,7 @@ export async function startLocalServer(opts) {
                                     const parsedTags = tagsMatch
                                         ? tagsMatch[1].split(',').map((tag) => tag.trim().replace(/^"|"$/g, '')).filter(Boolean)
                                         : [];
+                                    const llmMatch = /llmContext\s*=\s*"((?:[^"\\]|\\.)*)"/.exec(source);
                                     blocks.push({
                                         name: nameMatch?.[1] ?? entry.name.replace('.dql', ''),
                                         domain: domainMatch?.[1] ?? 'uncategorized',
@@ -431,6 +440,7 @@ export async function startLocalServer(opts) {
                                         path: relPath,
                                         lastModified: stat.mtime.toISOString(),
                                         description: descMatch?.[1] ?? '',
+                                        llmContext: llmMatch?.[1] ?? null,
                                     });
                                 }
                                 catch { /* skip unreadable files */ }
@@ -449,6 +459,58 @@ export async function startLocalServer(opts) {
             }
             return;
         }
+        // ── Apps (App artifact listing for notebook AppsPanel) ────────────────
+        if (req.method === 'GET' && path === '/api/apps') {
+            try {
+                const appsRoot = join(projectRoot, 'apps');
+                const apps = [];
+                const listFilesByExt = (dir, ext) => {
+                    const out = [];
+                    try {
+                        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                            const full = join(dir, entry.name);
+                            if (entry.isDirectory()) {
+                                out.push(...listFilesByExt(full, ext).map((n) => `${entry.name}/${n}`));
+                            }
+                            else if (entry.isFile() && entry.name.endsWith(ext)) {
+                                out.push(entry.name);
+                            }
+                        }
+                    }
+                    catch { /* dir missing; return [] */ }
+                    return out;
+                };
+                if (existsSync(appsRoot)) {
+                    for (const entry of readdirSync(appsRoot, { withFileTypes: true })) {
+                        if (!entry.isDirectory() || !entry.name.endsWith('.dql-app'))
+                            continue;
+                        const appDir = join(appsRoot, entry.name);
+                        try {
+                            const raw = readFileSync(join(appDir, 'app.yml'), 'utf-8');
+                            const manifest = loadYaml(raw);
+                            if (!manifest || !manifest.name || !manifest.domain)
+                                continue;
+                            apps.push({
+                                path: relative(projectRoot, appDir),
+                                manifest,
+                                notebooks: listFilesByExt(join(appDir, 'notebooks'), '.dqlnb'),
+                                dashboards: listFilesByExt(join(appDir, 'dashboards'), '.dql'),
+                                hasDigest: existsSync(join(appDir, 'digest.dql')),
+                            });
+                        }
+                        catch { /* skip unreadable apps */ }
+                    }
+                }
+                apps.sort((a, b) => a.manifest.name.localeCompare(b.manifest.name));
+                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(serializeJSON({ apps }));
+            }
+            catch (error) {
+                res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(serializeJSON({ error: error instanceof Error ? error.message : String(error) }));
+            }
+            return;
+        }
         // ── Block status update ──────────────────────────────────────────────
         if (req.method === 'POST' && path === '/api/blocks/status') {
             try {
@@ -512,6 +574,51 @@ export async function startLocalServer(opts) {
             }
             return;
         }
+        // ── Block body (re-read from disk, used by bound-cell refresh) ──────
+        if (req.method === 'GET' && path === '/api/blocks/body') {
+            try {
+                const blockPath = url.searchParams.get('path');
+                if (!blockPath) {
+                    res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(serializeJSON({ error: 'path parameter is required' }));
+                    return;
+                }
+                const absolutePath = resolve(projectRoot, blockPath);
+                if (!absolutePath.startsWith(projectRoot + '/') && absolutePath !== projectRoot) {
+                    res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(serializeJSON({ error: 'path escapes project root' }));
+                    return;
+                }
+                if (!existsSync(absolutePath)) {
+                    res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(serializeJSON({ error: 'block not found' }));
+                    return;
+                }
+                const body = readFileSync(absolutePath, 'utf-8');
+                let commitSha = null;
+                try {
+                    const { execSync } = await import('node:child_process');
+                    const sha = execSync(`git log -1 --format=%H -- "${blockPath}"`, {
+                        cwd: projectRoot,
+                        encoding: 'utf-8',
+                        stdio: ['ignore', 'pipe', 'ignore'],
+                        timeout: 5000,
+                    }).trim();
+                    commitSha = sha.length > 0 ? sha : null;
+                }
+                catch {
+                    commitSha = null;
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(serializeJSON({ path: blockPath, body, commitSha }));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(serializeJSON({ error: message }));
+            }
+            return;
+        }
         // ── Run block tests ────────────────────────────────────────────────
         if (req.method === 'POST' && path === '/api/blocks/run-tests') {
             try {
@@ -1293,6 +1400,42 @@ export async function startLocalServer(opts) {
             }
             return;
         }
+        if (req.method === 'POST' && path === '/api/llm/run') {
+            const body = await readJSON(req).catch(() => null);
+            if (!body || typeof body !== 'object') {
+                res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(serializeJSON({ error: 'Invalid JSON body' }));
+                return;
+            }
+            const { provider, messages, upstream } = body;
+            const runner = provider === 'claude-agent-sdk' || provider === 'claude-code' ? getLLMRunner(provider) : null;
+            if (!runner) {
+                res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(serializeJSON({ error: `Unknown provider: ${provider}` }));
+                return;
+            }
+            if (!Array.isArray(messages) || messages.length === 0) {
+                res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(serializeJSON({ error: 'messages[] required' }));
+                return;
+            }
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache, no-transform',
+                Connection: 'keep-alive',
+            });
+            const controller = new AbortController();
+            req.on('close', () => controller.abort());
+            const emit = (turn) => { res.write(`data: ${JSON.stringify(turn)}\n\n`); };
+            try {
+                await runner.run({ provider: provider, messages, upstream, projectRoot }, emit, controller.signal);
+            }
+            catch (err) {
+                emit({ kind: 'error', message: err instanceof Error ? err.message : String(err) });
+            }
+            res.end();
+            return;
+        }
         if (req.method === 'POST' && path === '/api/query') {
             try {
                 const body = await readJSON(req);
@@ -2826,6 +2969,9 @@ export function createBlockArtifacts(projectRoot, options) {
         owner: options.owner,
         description: options.description,
         tags: options.tags,
+        llmContext: options.llmContext,
+        examples: options.examples,
+        invariants: options.invariants,
         content: options.content?.trim() || templateContent,
     }));
     writeFileSync(blockPath, fileContent, 'utf-8');
@@ -3069,6 +3215,9 @@ function normalizeBlockStudioContent(options) {
         owner: options.owner,
         description: options.description,
         tags: options.tags,
+        llmContext: options.llmContext,
+        examples: options.examples,
+        invariants: options.invariants,
         sql: content || 'SELECT 1 AS value',
     });
 }
@@ -3081,6 +3230,28 @@ function buildBlankBlockContent(options) {
         `    owner = "${escapeDqlString(options.owner?.trim() ?? '')}"`,
     ];
     lines.push(`    tags = [${(options.tags ?? []).map((tag) => `"${escapeDqlString(tag)}"`).join(', ')}]`);
+    if (options.llmContext && options.llmContext.trim()) {
+        lines.push(`    llmContext = "${escapeDqlString(options.llmContext.trim())}"`);
+    }
+    if (options.invariants && options.invariants.length > 0) {
+        lines.push(`    invariants = [${options.invariants
+            .filter((inv) => inv && inv.trim())
+            .map((inv) => `"${escapeDqlString(inv.trim())}"`)
+            .join(', ')}]`);
+    }
+    if (options.examples && options.examples.length > 0) {
+        const items = options.examples.filter((ex) => ex.question && ex.question.trim());
+        if (items.length > 0) {
+            lines.push('    examples = [');
+            for (const ex of items) {
+                const parts = [`question = "${escapeDqlString(ex.question.trim())}"`];
+                if (ex.sql && ex.sql.trim())
+                    parts.push(`sql = "${escapeDqlString(ex.sql.trim())}"`);
+                lines.push(`        { ${parts.join(', ')} },`);
+            }
+            lines.push('    ]');
+        }
+    }
     lines.push('');
     lines.push('    query = """');
     lines.push(...indentBlock(options.sql.trim(), 8).split('\n'));