@cognite/cli 0.5.2 → 0.6.0-alpha.8

package/_templates/app/new/src/App.tsx.ejs.t

@@ -0,0 +1,265 @@
+---
+to: '<%= useCurrentDir ? "" : ((directoryName || name) + "/") %>src/App.tsx'
+---
+<% if (infra === 'appsApi') { -%>
+import { connectToHostApp } from '@cognite/app-sdk';
+<% } -%>
+import {
+  Alert,
+  AlertDescription,
+  Badge,
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+  Loader,
+  Separator,
+} from '@cognite/aura/components';
+<% if (infra !== 'appsApi') { -%>
+import { useDune } from '@cognite/dune';
+<% } -%>
+import { IconCaretUpDown, IconRocket } from '@tabler/icons-react';
+<% if (infra === 'appsApi') { -%>
+import { useEffect, useState } from 'react';
+<% } -%>
+
+import appConfig from '../app.json';
+
+const DUNE_DOCUMENTATION_HREF = 'https://laughing-adventure-r6kwpyy.pages.github.io/';
+
+const INTRO_COPY =
+  "Build and deploy React apps to Cognite Data Fusion in minutes. Aura, Cognite's AI-native design system, comes pre-configured so your app looks and feels at home from day one. Follow the checklist below to get started.";
+
+const CHECKLIST_STEPS = [
+  {
+    label: 'Plan',
+    badge: 'Step 1',
+    body: (
+      <>
+        Open <code>SPEC.md</code> at the repo root and describe what you want to build. If <code>.specify/</code> is
+        present, run <code>/speckit.specify</code> in Claude Code or Cursor to fill it in interactively. Otherwise, ask
+        your agent to collaborate on <code>SPEC.md</code> directly. Keep it simple and clear, then move on to building
+        when ready.
+      </>
+    ),
+  },
+  {
+    label: 'Explore',
+    badge: 'Step 2',
+    body: (
+      <>
+        Ask Cursor to review and understand your data model, then answer any follow-up questions it raises. Continue
+        refining the app by providing additional input as needed.
+      </>
+    ),
+  },
+  {
+    label: 'Deploy',
+    badge: 'Step 3',
+    body: (
+      <>
+        When ready to deploy, run <code>npx @cognite/dune deploy:interactive</code> in the terminal. Your app will
+        appear in the Fusion portal under Custom apps. Run the command again to redeploy new changes.
+      </>
+    ),
+  },
+] as const;
+
+function App() {
+<% if (infra === 'appsApi') { -%>
+  // Connect to the Fusion host via @cognite/app-sdk. The handshake is
+  // asynchronous — `project` is only populated after Comlink finishes
+  // exposing the host API, so we render a loader until then.
+  const [project, setProject] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | undefined>();
+
+  useEffect(() => {
+    let cancelled = false;
+    connectToHostApp({ applicationName: '<%= name %>' })
+      .then(async ({ api }) => {
+        if (cancelled) return;
+        const proj = await api.getProject();
+        if (cancelled) return;
+        setProject(proj);
+      })
+      .catch((err: unknown) => {
+        if (cancelled) return;
+        setError(err instanceof Error ? err.message : String(err));
+      })
+      .finally(() => {
+        if (!cancelled) setIsLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+<% } else { -%>
+  const { sdk, isLoading, error } = useDune();
+<% } -%>
+
+  if (isLoading) {
+    return (
+      <main className="min-h-screen bg-muted/50 text-foreground">
+        <section className="mx-auto flex min-h-screen w-full max-w-lg flex-col justify-center p-4 sm:p-8">
+          <div className="mx-auto w-full max-w-sm">
+            <Card aria-label="Loading project" aria-live="polite">
+              <CardContent>
+                <div className="inline-flex items-center gap-3 text-muted-foreground">
+                  <Loader size={20} />
+                  <span>Loading project...</span>
+                </div>
+              </CardContent>
+            </Card>
+          </div>
+        </section>
+      </main>
+    );
+  }
+
+<% if (infra === 'appsApi') { -%>
+  if (error) {
+    return (
+      <main className="min-h-screen bg-muted/50 text-foreground">
+        <section className="mx-auto flex min-h-screen w-full max-w-lg flex-col justify-center p-4 sm:p-8">
+          <div className="mx-auto w-full max-w-sm">
+            <Alert>
+              <AlertDescription>Failed to connect to Fusion host: {error}</AlertDescription>
+            </Alert>
+          </div>
+        </section>
+      </main>
+    );
+  }
+<% } else { -%>
+  if (error) {
+    return (
+      <main className="min-h-screen bg-muted/50 text-foreground">
+        <section className="mx-auto flex min-h-screen w-full max-w-lg flex-col justify-center p-4 sm:p-8">
+          <div className="mx-auto w-full max-w-sm">
+            <Alert>
+              <AlertDescription>{error}</AlertDescription>
+            </Alert>
+          </div>
+        </section>
+      </main>
+    );
+  }
+<% } -%>
+
+  const deployment = appConfig.deployments?.[0];
+  const orgLabel = deployment?.org ?? '';
+<% if (infra === 'appsApi') { -%>
+  const projectLabel = deployment?.project ?? project ?? '';
+<% } else { -%>
+  const projectLabel = deployment?.project ?? sdk.project;
+<% } -%>
+
+  return (
+    <main className="min-h-screen bg-muted/50 text-foreground">
+      <section className="mx-auto flex min-h-screen w-full max-w-3xl flex-col justify-center p-4 sm:p-8">
+        <Card>
+          <div className="p-15 gap-16">
+            <CardHeader>
+              <CardTitle as="h1">Welcome to Dune</CardTitle>
+              <CardDescription>{INTRO_COPY}</CardDescription>
+            </CardHeader>
+
+            <CardContent>
+              <Separator />
+
+              <div className="flex flex-col gap-6 pt-16">
+                <div className="flex items-center gap-2 pt-4">
+                  <IconRocket aria-hidden />
+                  <span className="text-2xl font-medium">App deployment checklist</span>
+                </div>
+
+                <div className="flex flex-col gap-4 px-4">
+                  {CHECKLIST_STEPS.map((step, index) => (
+                    <Collapsible key={step.label} defaultOpen={index === 0}>
+                      <CollapsibleTrigger className="w-full">
+                        <div className="flex w-full min-w-0 items-center justify-between gap-3 text-left">
+                          <span className="text-lg">{step.label}</span>
+                          <span className="inline-flex shrink-0 items-center gap-2">
+                            <Badge variant="mountain" background>
+                              {step.badge}
+                            </Badge>
+                            <IconCaretUpDown aria-hidden className="size-4 text-muted-foreground" />
+                          </span>
+                        </div>
+                      </CollapsibleTrigger>
+                      <CollapsibleContent>
+                        <div className="py-2">{step.body}</div>
+                      </CollapsibleContent>
+                    </Collapsible>
+                  ))}
+                </div>
+
+                <div className="mb-10">
+                  <Alert variant="secondary">
+                    <AlertDescription>
+                      <div className="flex flex-wrap items-center gap-2 text-lg">
+                        <span>Your app will deploy to</span>
+                        {orgLabel ? (
+                          <>
+                            <span>org</span>
+                            <Badge variant="nordic" background>
+                              {orgLabel}
+                            </Badge>
+                            <span>and project</span>
+                          </>
+                        ) : (
+                          <span>project</span>
+                        )}
+                        <Badge variant="nordic" background>
+                          {projectLabel}
+                        </Badge>
+                      </div>
+                    </AlertDescription>
+                  </Alert>
+                </div>
+
+                <Collapsible>
+                  <CollapsibleTrigger className="w-full">
+                    <div className="flex w-full min-w-0 items-center justify-between gap-3 text-left">
+                      <span className="text-lg">Support</span>
+                      <span className="inline-flex shrink-0 items-center gap-2">
+                        <Badge variant="mountain">
+                          Help & feedback
+                        </Badge>
+                        <IconCaretUpDown aria-hidden className="size-4 text-muted-foreground" />
+                      </span>
+                    </div>
+                  </CollapsibleTrigger>
+                  <CollapsibleContent>
+                    <div className="py-2">
+                      <p>
+                        For additional support and feedback, please head to{' '}
+                        <a
+                          href={DUNE_DOCUMENTATION_HREF}
+                          rel="noreferrer"
+                          style={{ color: '#486AED' }}
+                          target="_blank"
+                        >
+                          Dune documentation
+                        </a>{' '}
+                        or the{' '}
+                        <span style={{ color: '#486AED' }}>#Dune Slack channel</span>.
+                      </p>
+                    </div>
+                  </CollapsibleContent>
+                </Collapsible>
+              </div>
+            </CardContent>
+          </div>
+        </Card>
+      </section>
+    </main>
+  );
+}
+
+export default App;

package/_templates/app/new/src/lib/utils.ts.ejs.t

@@ -0,0 +1,9 @@
+---
+to: '<%= useCurrentDir ? "" : ((directoryName || name) + "/") %>src/lib/utils.ts'
+---
+import { type ClassValue, clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/_templates/app/new/src/main.tsx.ejs.t

@@ -0,0 +1,36 @@
+---
+to: '<%= useCurrentDir ? "" : ((directoryName || name) + "/") %>src/main.tsx'
+---
+<% if (infra !== 'appsApi') { -%>
+import { DuneAuthProvider } from '@cognite/dune';
+<% } -%>
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+
+import App from './App.tsx';
+
+import './styles.css';
+
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 5 * 60 * 1000, // 5 minutes
+      gcTime: 10 * 60 * 1000, // 10 minutes
+    },
+  },
+});
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <QueryClientProvider client={queryClient}>
+<% if (infra === 'appsApi') { -%>
+      <App />
+<% } else { -%>
+      <DuneAuthProvider>
+        <App />
+      </DuneAuthProvider>
+<% } -%>
+    </QueryClientProvider>
+  </React.StrictMode>
+);

package/_templates/app/new/src/styles.css.ejs.t

@@ -0,0 +1,12 @@
+---
+to: '<%= useCurrentDir ? "" : ((directoryName || name) + "/") %>src/styles.css'
+---
+@import '@cognite/aura/styles.source.css';
+
+@source '../node_modules/@cognite/aura/dist/components';
+
+:root {
+  --font-inter: "Inter", ui-sans-serif, system-ui, sans-serif;
+  --font-source-code-pro: "Source Code Pro", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas,
+    "Liberation Mono", "Courier New", monospace;
+}

package/_vendor/spec-kit/.version

@@ -0,0 +1,4 @@
+{
+  "tag": "v0.8.2",
+  "source": "https://github.com/github/spec-kit"
+}

package/_vendor/spec-kit/README.md

@@ -0,0 +1,39 @@
+# Vendored: github/spec-kit
+
+Selected, generated files from [github/spec-kit](https://github.com/github/spec-kit). Pinned version is in [`.version`](./.version).
+
+## Why this exists
+
+Dune app authors should not need Python, `uv`, or network access just because they pass `dune create --spec-kit`.
+
+Instead, Dune maintainers refresh spec-kit inside this monorepo, commit the selected generated files here, and let `dune create` copy them into new apps. That keeps end-user scaffolding fast and JS/TS-only while still letting us track upstream spec-kit intentionally.
+
+## Maintainer-only refresh
+
+The refresh script is for Dune monorepo maintainers only:
+
+```sh
+pnpm --filter @cognite/dune refresh-spec-kit <tag>
+```
+
+It requires `uv` locally, which provides `uvx`. That is acceptable for maintainers; it must not become a requirement for generated Dune apps.
+
+The script runs spec-kit's own `specify init` for the requested tag, stages the selected output in a temporary directory, and swaps it into `_vendor/spec-kit` only after all copies succeed.
+
+## What we vendor
+
+We vendor the parts Dune uses:
+
+- generated `commands/speckit.{specify,clarify,plan,tasks,implement,analyze,checklist}.md`
+- `templates/{spec,plan,tasks,checklist}-template.md`
+- `scripts/bash/{check-prerequisites,common,setup-plan}.sh`
+
+Deliberately excluded:
+
+- spec-kit's `AGENTS.md`, constitution command, and constitution template, because Dune uses the app's `AGENTS.md` as the constitution
+- integration metadata/workflows generated by `specify init`
+- optional commands such as taskstoissues
+- PowerShell scripts, until Dune chooses to support a PowerShell command set
+- spec-kit's Python CLI, tests, and docs
+
+**Cadence:** refresh at least once per Dune CLI minor release, sooner if upstream ships a fix we depend on.

package/_vendor/spec-kit/commands/speckit.analyze.md

@@ -0,0 +1,249 @@
+---
+description: Perform a non-destructive cross-artifact consistency and quality analysis across spec.md, plan.md, and tasks.md after task generation.
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Pre-Execution Checks
+
+**Check for extension hooks (before analysis)**:
+- Check if `.specify/extensions.yml` exists in the project root.
+- If it exists, read it and look for entries under the `hooks.before_analyze` key
+- If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
+- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+- For each executable hook, output the following based on its `optional` flag:
+  - **Optional hook** (`optional: true`):
+    ```
+    ## Extension Hooks
+
+    **Optional Pre-Hook**: {extension}
+    Command: `/{command}`
+    Description: {description}
+
+    Prompt: {prompt}
+    To execute: `/{command}`
+    ```
+  - **Mandatory hook** (`optional: false`):
+    ```
+    ## Extension Hooks
+
+    **Automatic Pre-Hook**: {extension}
+    Executing: `/{command}`
+    EXECUTE_COMMAND: {command}
+
+    Wait for the result of the hook command before proceeding to the Goal.
+    ```
+- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
+
+## Goal
+
+Identify inconsistencies, duplications, ambiguities, and underspecified items across the three core artifacts (`spec.md`, `plan.md`, `tasks.md`) before implementation. This command MUST run only after `/speckit.tasks` has successfully produced a complete `tasks.md`.
+
+## Operating Constraints
+
+**STRICTLY READ-ONLY**: Do **not** modify any files. Output a structured analysis report. Offer an optional remediation plan (user must explicitly approve before any follow-up editing commands would be invoked manually).
+
+**Constitution Authority**: The project constitution (`.specify/memory/constitution.md`) is **non-negotiable** within this analysis scope. Constitution conflicts are automatically CRITICAL and require adjustment of the spec, plan, or tasks—not dilution, reinterpretation, or silent ignoring of the principle. If a principle itself needs to change, that must occur in a separate, explicit constitution update outside `/speckit.analyze`.
+
+## Execution Steps
+
+### 1. Initialize Analysis Context
+
+Run `.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks` once from repo root and parse JSON for FEATURE_DIR and AVAILABLE_DOCS. Derive absolute paths:
+
+- SPEC = FEATURE_DIR/spec.md
+- PLAN = FEATURE_DIR/plan.md
+- TASKS = FEATURE_DIR/tasks.md
+
+Abort with an error message if any required file is missing (instruct the user to run missing prerequisite command).
+For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
+
+### 2. Load Artifacts (Progressive Disclosure)
+
+Load only the minimal necessary context from each artifact:
+
+**From spec.md:**
+
+- Overview/Context
+- Functional Requirements
+- Success Criteria (measurable outcomes — e.g., performance, security, availability, user success, business impact)
+- User Stories
+- Edge Cases (if present)
+
+**From plan.md:**
+
+- Architecture/stack choices
+- Data Model references
+- Phases
+- Technical constraints
+
+**From tasks.md:**
+
+- Task IDs
+- Descriptions
+- Phase grouping
+- Parallel markers [P]
+- Referenced file paths
+
+**From constitution:**
+
+- Load `.specify/memory/constitution.md` for principle validation
+
+### 3. Build Semantic Models
+
+Create internal representations (do not include raw artifacts in output):
+
+- **Requirements inventory**: For each Functional Requirement (FR-###) and Success Criterion (SC-###), record a stable key. Use the explicit FR-/SC- identifier as the primary key when present, and optionally also derive an imperative-phrase slug for readability (e.g., "User can upload file" → `user-can-upload-file`). Include only Success Criteria items that require buildable work (e.g., load-testing infrastructure, security audit tooling), and exclude post-launch outcome metrics and business KPIs (e.g., "Reduce support tickets by 50%").
+- **User story/action inventory**: Discrete user actions with acceptance criteria
+- **Task coverage mapping**: Map each task to one or more requirements or stories (inference by keyword / explicit reference patterns like IDs or key phrases)
+- **Constitution rule set**: Extract principle names and MUST/SHOULD normative statements
+
+### 4. Detection Passes (Token-Efficient Analysis)
+
+Focus on high-signal findings. Limit to 50 findings total; aggregate remainder in overflow summary.
+
+#### A. Duplication Detection
+
+- Identify near-duplicate requirements
+- Mark lower-quality phrasing for consolidation
+
+#### B. Ambiguity Detection
+
+- Flag vague adjectives (fast, scalable, secure, intuitive, robust) lacking measurable criteria
+- Flag unresolved placeholders (TODO, TKTK, ???, `<placeholder>`, etc.)
+
+#### C. Underspecification
+
+- Requirements with verbs but missing object or measurable outcome
+- User stories missing acceptance criteria alignment
+- Tasks referencing files or components not defined in spec/plan
+
+#### D. Constitution Alignment
+
+- Any requirement or plan element conflicting with a MUST principle
+- Missing mandated sections or quality gates from constitution
+
+#### E. Coverage Gaps
+
+- Requirements with zero associated tasks
+- Tasks with no mapped requirement/story
+- Success Criteria requiring buildable work (performance, security, availability) not reflected in tasks
+
+#### F. Inconsistency
+
+- Terminology drift (same concept named differently across files)
+- Data entities referenced in plan but absent in spec (or vice versa)
+- Task ordering contradictions (e.g., integration tasks before foundational setup tasks without dependency note)
+- Conflicting requirements (e.g., one requires Next.js while other specifies Vue)
+
+### 5. Severity Assignment
+
+Use this heuristic to prioritize findings:
+
+- **CRITICAL**: Violates constitution MUST, missing core spec artifact, or requirement with zero coverage that blocks baseline functionality
+- **HIGH**: Duplicate or conflicting requirement, ambiguous security/performance attribute, untestable acceptance criterion
+- **MEDIUM**: Terminology drift, missing non-functional task coverage, underspecified edge case
+- **LOW**: Style/wording improvements, minor redundancy not affecting execution order
+
+### 6. Produce Compact Analysis Report
+
+Output a Markdown report (no file writes) with the following structure:
+
+## Specification Analysis Report
+
+| ID | Category | Severity | Location(s) | Summary | Recommendation |
+|----|----------|----------|-------------|---------|----------------|
+| A1 | Duplication | HIGH | spec.md:L120-134 | Two similar requirements ... | Merge phrasing; keep clearer version |
+
+(Add one row per finding; generate stable IDs prefixed by category initial.)
+
+**Coverage Summary Table:**
+
+| Requirement Key | Has Task? | Task IDs | Notes |
+|-----------------|-----------|----------|-------|
+
+**Constitution Alignment Issues:** (if any)
+
+**Unmapped Tasks:** (if any)
+
+**Metrics:**
+
+- Total Requirements
+- Total Tasks
+- Coverage % (requirements with >=1 task)
+- Ambiguity Count
+- Duplication Count
+- Critical Issues Count
+
+### 7. Provide Next Actions
+
+At end of report, output a concise Next Actions block:
+
+- If CRITICAL issues exist: Recommend resolving before `/speckit.implement`
+- If only LOW/MEDIUM: User may proceed, but provide improvement suggestions
+- Provide explicit command suggestions: e.g., "Run /speckit.specify with refinement", "Run /speckit.plan to adjust architecture", "Manually edit tasks.md to add coverage for 'performance-metrics'"
+
+### 8. Offer Remediation
+
+Ask the user: "Would you like me to suggest concrete remediation edits for the top N issues?" (Do NOT apply them automatically.)
+
+### 9. Check for extension hooks
+
+After reporting, check if `.specify/extensions.yml` exists in the project root.
+- If it exists, read it and look for entries under the `hooks.after_analyze` key
+- If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
+- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+- For each executable hook, output the following based on its `optional` flag:
+  - **Optional hook** (`optional: true`):
+    ```
+    ## Extension Hooks
+
+    **Optional Hook**: {extension}
+    Command: `/{command}`
+    Description: {description}
+
+    Prompt: {prompt}
+    To execute: `/{command}`
+    ```
+  - **Mandatory hook** (`optional: false`):
+    ```
+    ## Extension Hooks
+
+    **Automatic Hook**: {extension}
+    Executing: `/{command}`
+    EXECUTE_COMMAND: {command}
+    ```
+- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
+
+## Operating Principles
+
+### Context Efficiency
+
+- **Minimal high-signal tokens**: Focus on actionable findings, not exhaustive documentation
+- **Progressive disclosure**: Load artifacts incrementally; don't dump all content into analysis
+- **Token-efficient output**: Limit findings table to 50 rows; summarize overflow
+- **Deterministic results**: Rerunning without changes should produce consistent IDs and counts
+
+### Analysis Guidelines
+
+- **NEVER modify files** (this is read-only analysis)
+- **NEVER hallucinate missing sections** (if absent, report them accurately)
+- **Prioritize constitution violations** (these are always CRITICAL)
+- **Use examples over exhaustive rules** (cite specific instances, not generic patterns)
+- **Report zero issues gracefully** (emit success report with coverage statistics)
+
+## Context
+
+$ARGUMENTS