@duckcodeailabs/dql-cli 1.13.3 → 1.13.4

package/dist/local-runtime.js

@@ -48,6 +48,7 @@ import { buildSemanticTargetBinding } from './semantic-execution/target-binding.
 import { discoverWarehouseMetadataScopes, normalizeConnectionMetadataScope, syncWarehouseMetadata, warehouseMetadataStatus, } from './warehouse-metadata.js';
 import { NotebookDatasetWorkspace, } from "./notebook-datasets.js";
 import { prepareBlockInvocation } from './block-invocation.js';
+export const APP_SOURCE_REUSABLE_TAG = 'app-source';
 const NOTEBOOK_EXECUTE_PREVIEW_ROW_LIMIT = 500;
 const NOTEBOOK_FAVICON_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" rx="7" fill="#6d5dfc"/><path d="M9 9h14v14H9z" fill="none" stroke="#fff" stroke-width="2"/><path d="M13 13h6M13 17h6M13 21h4" stroke="#fff" stroke-width="2" stroke-linecap="round"/></svg>';
 export function resolveProjectSemanticConfig(projectConfig, projectRoot) {
@@ -5809,10 +5810,20 @@ export async function startLocalServer(opts) {
         };
     };
     const certifyBlockStudioSource = async (source, blockPath, options = {}) => {
+        options.reportProgress?.({
+            phase: 'validating',
+            progress: 10,
+            message: 'Validating the saved DQL source.',
+        });
         let validation = validateBlockStudioSource(source, semanticLayer);
         let preview = null;
         let testResults = null;
         const blockers = [];
+        options.reportProgress?.({
+            phase: 'previewing',
+            progress: 30,
+            message: 'Compiling and previewing the saved block.',
+        });
         try {
             preview = await runBlockStudioPreviewSource(source);
             validation = preview.validation;
@@ -5820,6 +5831,11 @@ export async function startLocalServer(opts) {
         catch (error) {
             blockers.push(error instanceof Error ? error.message : String(error));
         }
+        options.reportProgress?.({
+            phase: 'testing',
+            progress: 60,
+            message: 'Evaluating declared block tests.',
+        });
         try {
             testResults = preview
                 ? await runBlockStudioTestSummary(source, undefined, preview)
@@ -5835,6 +5851,11 @@ export async function startLocalServer(opts) {
                 runAt: new Date(),
             };
         }
+        options.reportProgress?.({
+            phase: 'assessing',
+            progress: 75,
+            message: 'Assessing certification rules and evidence.',
+        });
         const parsed = parseBlockSourceMetadata(source);
         const record = {
             id: parsed.name || 'local',
@@ -11689,7 +11710,7 @@ export async function startLocalServer(opts) {
                             return;
                         }
                     }
-                    const draftSource = setBlockStudioStatusInSource(source, 'draft');
+                    const draftSource = markBlockStudioSourceReusable(setBlockStudioStatusInSource(source, 'draft'));
                     const parsed = parseBlockSourceMetadata(draftSource);
                     const name = typeof suppliedMetadata.name === 'string' && suppliedMetadata.name.trim()
                         ? suppliedMetadata.name.trim()
@@ -11710,7 +11731,10 @@ export async function startLocalServer(opts) {
                         domain: typeof suppliedMetadata.domain === 'string' ? suppliedMetadata.domain : parsed.domain,
                         description: typeof suppliedMetadata.description === 'string' ? suppliedMetadata.description : parsed.description,
                         owner: typeof suppliedMetadata.owner === 'string' ? suppliedMetadata.owner : parsed.owner,
-                        tags: Array.isArray(suppliedMetadata.tags) ? suppliedMetadata.tags.map(String) : parsed.tags,
+                        tags: Array.from(new Set([
+                            ...(Array.isArray(suppliedMetadata.tags) ? suppliedMetadata.tags.map(String) : parsed.tags),
+                            APP_SOURCE_REUSABLE_TAG,
+                        ])),
                         lineage: Array.isArray(suppliedMetadata.lineage) ? suppliedMetadata.lineage.map(String) : undefined,
                     };
                     // A saved draft already has a durable identity, even when it lives in
@@ -11747,8 +11771,14 @@ export async function startLocalServer(opts) {
                         }
                     }
                     operationCoordinator.run(operation.id, async (signal, report) => {
-                        report({ phase: 'validating', progress: 15, message: 'Validating and running the saved draft once.' });
-                        const result = await certifyBlockStudioSource(draftSource, draftPath, { enterprise: body.enterprise === true });
+                        const result = await certifyBlockStudioSource(draftSource, draftPath, {
+                            enterprise: body.enterprise === true,
+                            reportProgress: (progress) => {
+                                if (signal.aborted)
+                                    throw Object.assign(new Error('Certification cancelled.'), { code: 'OPERATION_CANCELLED' });
+                                report(progress);
+                            },
+                        });
                         const blockers = Array.from(new Set(result.checklist.blockers));
                         if (signal.aborted)
                             throw Object.assign(new Error('Certification cancelled.'), { code: 'OPERATION_CANCELLED' });
@@ -11771,7 +11801,7 @@ export async function startLocalServer(opts) {
                                 block: { ...openedDraft, validation: result.validation },
                             };
                         }
-                        report({ phase: 'publishing', progress: 80, message: 'Publishing the certified block.' });
+                        report({ phase: 'publishing', progress: 82, message: 'Publishing the certified block.' });
                         const certifiedSource = setBlockStudioStatusInSource(draftSource, 'certified');
                         const certifiedMetadata = parseBlockSourceMetadata(certifiedSource);
                         const savedPath = saveBlockStudioArtifacts(projectRoot, {
@@ -11813,7 +11843,9 @@ export async function startLocalServer(opts) {
                         catch {
                             /* best-effort: learning capture must never block certification */
                         }
+                        report({ phase: 'indexing', progress: 92, message: 'Queueing the certified source index refresh.' });
                         const refreshOperation = scheduleProjectRefresh('block-studio-certification');
+                        report({ phase: 'indexing', progress: 96, message: 'Certified source saved; index refresh queued.' });
                         if (result.preview)
                             writeBlockStudioRunSummary(projectRoot, savedPath, certifiedSource, result.preview.result);
                         const openedCertified = openBlockStudioDocument(projectRoot, savedPath, semanticLayer);
@@ -12493,13 +12525,14 @@ export async function startLocalServer(opts) {
                             }));
                             return;
                         }
+                        const reusableSource = markBlockStudioSourceReusable(readiness.candidate.dqlSource);
                         const savedPath = saveBlockStudioArtifacts(projectRoot, {
-                            source: readiness.candidate.dqlSource,
+                            source: reusableSource,
                             name: readiness.candidate.name,
                             domain: readiness.candidate.domain,
                             description: readiness.candidate.description,
                             owner: readiness.candidate.owner,
-                            tags: readiness.candidate.tags,
+                            tags: Array.from(new Set([...readiness.candidate.tags, APP_SOURCE_REUSABLE_TAG])),
                             lineage: readiness.candidate.lineage.sourceTables,
                             importMeta: {
                                 importId,
@@ -12508,7 +12541,13 @@ export async function startLocalServer(opts) {
                                 sourcePath: readiness.candidate.sourcePath,
                             },
                         });
-                        const next = { ...readiness.candidate, reviewStatus: 'saved', savedPath };
+                        const next = {
+                            ...readiness.candidate,
+                            dqlSource: reusableSource,
+                            tags: Array.from(new Set([...readiness.candidate.tags, APP_SOURCE_REUSABLE_TAG])),
+                            reviewStatus: 'saved',
+                            savedPath,
+                        };
                         writeBlockStudioImportCandidate(projectRoot, importId, next);
                         await refreshLocalMetadataCatalog(projectRoot);
                         const payload = openBlockStudioDocument(projectRoot, savedPath, semanticLayer);
@@ -12751,7 +12790,7 @@ export async function startLocalServer(opts) {
                 try {
                     const body = await readJSON(req);
                     const source = typeof body.source === 'string'
-                        ? sanitizeAgentBlockDraftSource(body.source)
+                        ? markBlockStudioSourceReusable(sanitizeAgentBlockDraftSource(body.source))
                         : '';
                     const name = typeof body.name === 'string' ? body.name.trim() : '';
                     if (!source.trim() || !name) {
@@ -12764,7 +12803,10 @@ export async function startLocalServer(opts) {
                         name,
                         domain: typeof body.domain === 'string' ? body.domain : undefined,
                         description: typeof body.description === 'string' ? body.description : undefined,
-                        tags: Array.isArray(body.tags) ? body.tags.map(String) : ['ai-generated', 'review-required'],
+                        tags: Array.from(new Set([
+                            ...(Array.isArray(body.tags) ? body.tags.map(String) : ['ai-generated', 'review-required']),
+                            APP_SOURCE_REUSABLE_TAG,
+                        ])),
                         stableSuffix: typeof body.runId === 'string' ? body.runId : undefined,
                     });
                     const payload = openBlockStudioDocument(projectRoot, savedPath, semanticLayer);
@@ -12780,7 +12822,9 @@ export async function startLocalServer(opts) {
             if (req.method === 'POST' && path === '/api/block-studio/save') {
                 try {
                     const body = await readJSON(req);
-                    const source = typeof body.source === 'string' ? body.source : '';
+                    const source = typeof body.source === 'string'
+                        ? markBlockStudioSourceReusable(body.source)
+                        : '';
                     const metadata = body.metadata && typeof body.metadata === 'object'
                         ? body.metadata
                         : {};
@@ -12817,7 +12861,10 @@ export async function startLocalServer(opts) {
                         folderPath: metadata.folderPath,
                         description: metadata.description,
                         owner: metadata.owner,
-                        tags: Array.isArray(metadata.tags) ? metadata.tags.map(String) : [],
+                        tags: Array.from(new Set([
+                            ...(Array.isArray(metadata.tags) ? metadata.tags.map(String) : []),
+                            APP_SOURCE_REUSABLE_TAG,
+                        ])),
                         lineage: Array.isArray(metadata.lineage) ? metadata.lineage.map(String) : undefined,
                         importMeta: metadata.sourceKind || metadata.sourcePath || metadata.importId || metadata.candidateId
                             ? {
@@ -21745,14 +21792,18 @@ export function validateBlockStudioSource(source, semanticLayer) {
     };
 }
 export async function createDqlArtifactGenerationSessionForProject(projectRoot, options, semanticLayer) {
-    const dqlArtifact = normalizeDqlArtifactReference(options.dqlArtifact);
-    if (!dqlArtifact)
+    const normalizedDqlArtifact = normalizeDqlArtifactReference(options.dqlArtifact);
+    if (!normalizedDqlArtifact)
         throw new Error('A DQL artifact with source is required for DQL draft promotion.');
+    const dqlArtifact = {
+        ...normalizedDqlArtifact,
+        source: markBlockStudioSourceReusable(normalizedDqlArtifact.source),
+    };
     const question = notebookResearchString(options.question) ?? dqlArtifact.name ?? 'Generated DQL artifact';
     const slug = deriveGeneratedDraftSlug(dqlArtifact.name ?? question);
     const domain = notebookResearchString(options.domain) ?? 'misc';
     const owner = notebookResearchString(options.owner) ?? '';
-    const tags = Array.from(new Set(['notebook-research', 'review-required', 'dql-artifact', ...(Array.isArray(options.tags) ? options.tags : [])]
+    const tags = Array.from(new Set(['notebook-research', 'review-required', 'dql-artifact', APP_SOURCE_REUSABLE_TAG, ...(Array.isArray(options.tags) ? options.tags : [])]
         .map((tag) => notebookResearchString(tag))
         .filter((tag) => Boolean(tag))));
     const proposedContractId = `${domain}.Unknown.${slug}`;
@@ -22646,6 +22697,23 @@ export function parseBlockSourceMetadata(source) {
         metricsRef: extractStringArray('metrics'),
     };
 }
+/**
+ * Persist the explicit App-source reuse decision in canonical DQL. Generated
+ * execution stays transient; only Block Studio save/promotion routes call this
+ * helper. The marker is a normal parser-supported tag, so refresh/reindex can
+ * make the participation decision without relying on filenames or prose.
+ */
+export function markBlockStudioSourceReusable(source) {
+    const parsed = parseBlockSourceMetadata(source);
+    if (parsed.tags.some((tag) => tag.trim().toLowerCase() === APP_SOURCE_REUSABLE_TAG))
+        return source;
+    const tags = Array.from(new Set([...parsed.tags, APP_SOURCE_REUSABLE_TAG]));
+    const rendered = tags.map((tag) => JSON.stringify(tag)).join(', ');
+    if (/\btags\s*=\s*\[[\s\S]*?\]/i.test(source)) {
+        return source.replace(/\btags\s*=\s*\[[\s\S]*?\]/i, `tags = [${rendered}]`);
+    }
+    return source.replace(/(\bblock\s+"[^"]+"\s*\{)/i, `$1\n  tags = [${rendered}]`);
+}
 function compareBlockStudioValues(actual, operator, expected) {
     const expectedValue = normalizeBlockStudioExpected(expected);
     if (operator === '==' || operator === '=')