@duckcodeailabs/dql-cli 1.5.2 → 1.6.0

package/dist/local-runtime.js

@@ -1043,7 +1043,7 @@ export async function startLocalServer(opts) {
         if (req.method === 'POST' && path === '/api/blocks') {
             try {
                 const body = await readJSON(req);
-                const { name, domain, content, description, tags, metricRefs, template, } = body;
+                const { name, domain, content, description, tags, metricRefs, template, blockType, } = body;
                 if (!name || typeof name !== 'string') {
                     res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
                     res.end(serializeJSON({ error: 'Missing block name' }));
@@ -1057,6 +1057,7 @@ export async function startLocalServer(opts) {
                     tags,
                     metricRefs,
                     template,
+                    blockType,
                 });
                 res.writeHead(201, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.end(serializeJSON(created));
@@ -1637,6 +1638,18 @@ export async function startLocalServer(opts) {
             }
             return;
         }
+        if (req.method === 'GET' && path === '/api/block-studio/dbt-status') {
+            try {
+                const status = buildDbtStatus(projectRoot, projectConfig, semanticLastSyncTime);
+                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(serializeJSON(status));
+            }
+            catch (error) {
+                res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(serializeJSON({ error: error instanceof Error ? error.message : String(error) }));
+            }
+            return;
+        }
         if (req.method === 'GET' && path === '/api/block-studio/open') {
             try {
                 const relativePath = url.searchParams.get('path');
@@ -4466,17 +4479,25 @@ export function createBlockArtifacts(projectRoot, options) {
         ? listBlockTemplates().find((template) => template.id === options.template)?.content
         : undefined;
     const relativePath = safeDomain ? `blocks/${safeDomain}/${slug}.dql` : `blocks/${slug}.dql`;
-    const fileContent = canonicalizeSafe(normalizeBlockStudioContent({
-        name: options.name,
-        domain: safeDomain || 'uncategorized',
-        owner: options.owner,
-        description: options.description,
-        tags: options.tags,
-        llmContext: options.llmContext,
-        examples: options.examples,
-        invariants: options.invariants,
-        content: options.content?.trim() || templateContent,
-    }));
+    const fileContent = canonicalizeSafe(options.blockType === 'semantic' && !options.content?.trim() && !templateContent
+        ? buildBlankSemanticBlockContent({
+            name: options.name,
+            domain: safeDomain || 'uncategorized',
+            owner: options.owner,
+            description: options.description,
+            tags: options.tags,
+        })
+        : normalizeBlockStudioContent({
+            name: options.name,
+            domain: safeDomain || 'uncategorized',
+            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');
     const companionPath = writeBlockCompanionFile(projectRoot, {
         slug,
@@ -4777,6 +4798,25 @@ function buildBlankBlockContent(options) {
     lines.push('}');
     return lines.join('\n') + '\n';
 }
+function buildBlankSemanticBlockContent(options) {
+    const lines = [
+        `block "${escapeDqlString(options.name)}" {`,
+        `    domain = "${escapeDqlString(options.domain)}"`,
+        '    type = "semantic"',
+        '    status = "draft"',
+        `    description = "${escapeDqlString(options.description?.trim() || options.name)}"`,
+        `    owner = "${escapeDqlString(options.owner?.trim() ?? '')}"`,
+        `    tags = [${(options.tags ?? []).map((tag) => `"${escapeDqlString(tag)}"`).join(', ')}]`,
+        '    metric = ""',
+        '    dimensions = []',
+        '',
+        '    visualization {',
+        '        chart = "table"',
+        '    }',
+        '}',
+    ];
+    return lines.join('\n') + '\n';
+}
 function parseYamlScalar(value) {
     const trimmed = value.trim();
     if (!trimmed)
@@ -4905,6 +4945,101 @@ function resolveDbtManifestPath(projectRoot) {
     const candidate = join(projectRoot, 'target', 'manifest.json');
     return existsSync(candidate) ? candidate : undefined;
 }
+export function buildDbtStatus(projectRoot, projectConfig, lastSyncTime) {
+    const configuredDbtDir = projectConfig.dbt?.projectDir
+        ? resolve(projectRoot, projectConfig.dbt.projectDir)
+        : undefined;
+    const semanticDbtDir = projectConfig.semanticLayer?.provider === 'dbt' && projectConfig.semanticLayer.projectPath
+        ? resolve(projectRoot, projectConfig.semanticLayer.projectPath)
+        : undefined;
+    const candidateDirs = [
+        configuredDbtDir,
+        semanticDbtDir,
+        projectRoot,
+        resolve(projectRoot, '..'),
+        resolve(projectRoot, '../dbt'),
+        resolve(projectRoot, '../../dbt'),
+    ].filter((value) => Boolean(value));
+    const dbtProjectPath = candidateDirs.find((dir, index, list) => list.indexOf(dir) === index && existsSync(join(dir, 'dbt_project.yml'))) ?? configuredDbtDir ?? semanticDbtDir ?? projectRoot;
+    const configuredManifest = projectConfig.dbt?.manifestPath ?? 'target/manifest.json';
+    const manifestPath = resolve(dbtProjectPath, configuredManifest);
+    const catalogPath = resolve(dbtProjectPath, 'target/catalog.json');
+    const semanticManifestPath = resolve(dbtProjectPath, 'target/semantic_manifest.json');
+    const runResultsPath = resolve(dbtProjectPath, 'target/run_results.json');
+    const manifest = readJsonFile(manifestPath);
+    const semanticManifest = readJsonFile(semanticManifestPath);
+    const projectName = typeof manifest?.metadata?.project_name === 'string'
+        ? manifest.metadata.project_name
+        : null;
+    const nodes = manifest && typeof manifest === 'object' && manifest.nodes && typeof manifest.nodes === 'object'
+        ? Object.values(manifest.nodes)
+        : [];
+    const modelCount = nodes.filter((node) => node?.resource_type === 'model').length;
+    const sourceCount = manifest?.sources && typeof manifest.sources === 'object'
+        ? Object.keys(manifest.sources).length
+        : 0;
+    const manifestMetricCount = manifest?.metrics && typeof manifest.metrics === 'object'
+        ? Object.keys(manifest.metrics).length
+        : 0;
+    const semanticMetricCount = Array.isArray(semanticManifest?.metrics)
+        ? semanticManifest.metrics.length
+        : manifestMetricCount;
+    const semanticModelCount = Array.isArray(semanticManifest?.semantic_models)
+        ? semanticManifest.semantic_models.length
+        : 0;
+    const savedQueryCount = Array.isArray(semanticManifest?.saved_queries)
+        ? semanticManifest.saved_queries.length
+        : 0;
+    const configured = existsSync(join(dbtProjectPath, 'dbt_project.yml')) || Boolean(configuredDbtDir || semanticDbtDir);
+    const manifestExists = existsSync(manifestPath);
+    const semanticExists = existsSync(semanticManifestPath);
+    const setupHint = !configured
+        ? 'No dbt project detected. Start without dbt or run DQL from a repo with dbt_project.yml.'
+        : !manifestExists
+            ? 'Run `dbt parse`, `dbt compile`, or `dbt build`, then run `dql sync dbt`.'
+            : !semanticExists
+                ? 'dbt manifest is ready. Run `dbt parse` or `dbt build` if you use dbt Semantic Layer metrics.'
+                : 'dbt artifacts are ready. Build SQL blocks from models or semantic blocks from metrics.';
+    return {
+        configured,
+        provider: projectConfig.semanticLayer?.provider ?? null,
+        projectPath: dbtProjectPath,
+        projectName,
+        artifacts: {
+            manifest: describeArtifact(manifestPath, modelCount + sourceCount, manifest?.metadata?.generated_at),
+            catalog: describeArtifact(catalogPath),
+            semanticManifest: describeArtifact(semanticManifestPath, semanticMetricCount + semanticModelCount + savedQueryCount, semanticManifest?.metadata?.generated_at),
+            runResults: describeArtifact(runResultsPath),
+        },
+        counts: {
+            models: modelCount,
+            sources: sourceCount,
+            metrics: semanticMetricCount,
+            semanticModels: semanticModelCount,
+            savedQueries: savedQueryCount,
+        },
+        lastSyncTime,
+        setupHint,
+    };
+}
+function describeArtifact(path, count, generatedAt) {
+    return {
+        path,
+        exists: existsSync(path),
+        count,
+        generatedAt: generatedAt ?? null,
+    };
+}
+function readJsonFile(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
 function resolveLineageNode(graph, rawNodeId) {
     if (graph.getNode(rawNodeId))
         return graph.getNode(rawNodeId);