@uns-kit/cli 0.0.13 → 0.0.15

package/README.md

@@ -25,6 +25,8 @@ pnpm run dev
 
 - `uns-kit create <name>` – create a new UNS project in the specified directory.
 - `uns-kit configure-devops [path]` – add Azure DevOps tooling (dependencies, script, config) to an existing project.
+- `uns-kit configure-vscode [path]` – copy VS Code launch/workspace files into an existing project.
+- `uns-kit configure-codegen [path]` – scaffold GraphQL code generation and UNS refresh scripts.
 - `uns-kit help` – display usage information.
 
 ### Configure Azure DevOps
@@ -37,7 +39,26 @@ pnpm install
 pnpm run pull-request
 ```
 
-The command prompts for your Azure DevOps organization and updates `config.json` along with the necessary dev dependencies.
+The command prompts for your Azure DevOps organization/project, ensures the remote repository exists, and updates `config.json` along with the necessary dev dependencies.
+
+### Configure VS Code workspace
+
+```bash
+uns-kit configure-vscode
+```
+
+Copies `.vscode/launch.json` plus a baseline workspace file into the project. Existing files are never overwritten, making it safe to re-run after hand edits.
+
+### Configure GraphQL code generation
+
+```bash
+uns-kit configure-codegen
+pnpm install
+pnpm run codegen
+pnpm run refresh-uns
+```
+
+Adds `codegen.ts`, seeds `src/uns/` placeholder types, and wires the GraphQL Code Generator / `refresh-uns` script into `package.json`. After installing the new dev dependencies you can regenerate strongly-typed operations (`pnpm run codegen`) and rebuild UNS topics/tags from your environment (`pnpm run refresh-uns`).
 
 ### Extend the Config Schema
 

package/dist/index.js

@@ -1,17 +1,19 @@
 #!/usr/bin/env node
 import { execFile } from "node:child_process";
-import { access, cp, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { access, cp, mkdir, readFile, readdir, stat, writeFile, copyFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import process from "node:process";
 import readline from "node:readline/promises";
 import { promisify } from "node:util";
+import * as azdev from "azure-devops-node-api";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const require = createRequire(import.meta.url);
 const coreVersion = resolveCoreVersion();
 const execFileAsync = promisify(execFile);
+const AZURE_DEVOPS_PROVIDER = "azure-devops";
 async function main() {
     const args = process.argv.slice(2);
     const command = args[0];
@@ -30,6 +32,28 @@ async function main() {
         }
         return;
     }
+    if (command === "configure-vscode") {
+        const targetPath = args[1];
+        try {
+            await configureVscode(targetPath);
+        }
+        catch (error) {
+            console.error(error.message);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (command === "configure-codegen") {
+        const targetPath = args[1];
+        try {
+            await configureCodegen(targetPath);
+        }
+        catch (error) {
+            console.error(error.message);
+            process.exitCode = 1;
+        }
+        return;
+    }
     if (command === "create") {
         const projectName = args[1];
         if (!projectName) {
@@ -51,7 +75,13 @@ async function main() {
     process.exitCode = 1;
 }
 function printHelp() {
-    console.log(`\nUsage: uns-kit <command> [options]\n\nCommands:\n  create <name>           Scaffold a new UNS application\n  configure-devops [dir]  Configure Azure DevOps tooling in an existing project\n  help                    Show this message\n`);
+    console.log("\nUsage: uns-kit <command> [options]\n" +
+        "\nCommands:\n" +
+        "  create <name>           Scaffold a new UNS application\n" +
+        "  configure-devops [dir]  Configure Azure DevOps tooling in an existing project\n" +
+        "  configure-vscode [dir]  Add VS Code workspace configuration files\n" +
+        "  configure-codegen [dir] Copy GraphQL codegen template and dependencies\n" +
+        "  help                    Show this message\n");
 }
 async function createProject(projectName) {
     const targetDir = path.resolve(process.cwd(), projectName);
@@ -96,25 +126,45 @@ async function configureDevops(targetPath) {
     const config = JSON.parse(configRaw);
     await ensureGitRepository(targetDir);
     const remoteUrl = await getGitRemoteUrl(targetDir, "origin");
-    let gitRemoteMessage;
-    let ensuredRemoteUrl = remoteUrl;
-    if (!ensuredRemoteUrl) {
-        const remoteAnswer = (await promptQuestion("Azure DevOps repository URL (e.g. https://dev.azure.com/sijit/industry40/_git/my-repo): ")).trim();
-        if (!remoteAnswer) {
-            throw new Error("A repository URL is required to set the git remote origin.");
-        }
-        await addGitRemote(targetDir, "origin", remoteAnswer);
-        ensuredRemoteUrl = remoteAnswer;
-        gitRemoteMessage = `  Added git remote origin -> ${remoteAnswer}`;
-    }
-    const inferredOrganization = ensuredRemoteUrl ? inferAzureOrganization(ensuredRemoteUrl) : undefined;
-    const defaultOrg = config.devops?.organization?.trim() || inferredOrganization || "sijit";
-    const answer = (await promptQuestion(`Azure DevOps organization [${defaultOrg}]: `)).trim();
-    const organization = answer || defaultOrg;
+    const remoteInfo = remoteUrl ? parseAzureRemote(remoteUrl) : undefined;
+    const repositoryName = inferRepositoryNameFromPackage(pkg.name) || inferRepositoryNameFromPackage(path.basename(targetDir));
+    const defaultOrganization = config.devops?.organization?.trim() || remoteInfo?.organization || "sijit";
+    const organization = await promptWithDefault(defaultOrganization ? `Azure DevOps organization [${defaultOrganization}]: ` : "Azure DevOps organization: ", defaultOrganization, "Azure DevOps organization is required.");
+    const defaultProject = config.devops?.project?.trim() || remoteInfo?.project || "";
+    const project = await promptWithDefault(defaultProject ? `Azure DevOps project [${defaultProject}]: ` : "Azure DevOps project: ", defaultProject, "Azure DevOps project is required.");
     if (!config.devops || typeof config.devops !== "object") {
         config.devops = {};
     }
-    config.devops.organization = organization;
+    const devopsConfig = config.devops;
+    devopsConfig.provider = AZURE_DEVOPS_PROVIDER;
+    devopsConfig.organization = organization;
+    devopsConfig.project = project;
+    let gitRemoteMessage;
+    let repositoryUrlMessage;
+    let ensuredRemoteUrl = remoteUrl ?? "";
+    if (!remoteUrl) {
+        const { gitApi } = await resolveAzureGitApi(organization);
+        const repositoryDetails = await ensureAzureRepositoryExists(gitApi, {
+            organization,
+            project,
+            repository: repositoryName,
+        });
+        ensuredRemoteUrl = repositoryDetails.remoteUrl ?? buildAzureGitRemoteUrl(organization, project, repositoryName);
+        await addGitRemote(targetDir, "origin", ensuredRemoteUrl);
+        gitRemoteMessage = `  Added git remote origin -> ${ensuredRemoteUrl}`;
+        const friendlyUrl = repositoryDetails.webUrl ?? buildAzureRepositoryUrl(organization, project, repositoryName);
+        if (friendlyUrl) {
+            repositoryUrlMessage = `  Repository URL: ${friendlyUrl}`;
+        }
+    }
+    else {
+        ensuredRemoteUrl = remoteUrl;
+        gitRemoteMessage = `  Git remote origin detected -> ${ensuredRemoteUrl}`;
+        const friendlyUrl = buildAzureRepositoryUrl(remoteInfo?.organization ?? organization, remoteInfo?.project ?? project, remoteInfo?.repository ?? repositoryName);
+        if (friendlyUrl) {
+            repositoryUrlMessage = `  Repository URL: ${friendlyUrl}`;
+        }
+    }
     const requiredDevDeps = {
         "azure-devops-node-api": "^15.1.0",
         "simple-git": "^3.27.0",
@@ -140,7 +190,12 @@ async function configureDevops(targetPath) {
         await writeFile(packagePath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     }
     console.log(`\nDevOps tooling configured.`);
+    console.log(`  DevOps provider: ${AZURE_DEVOPS_PROVIDER}`);
     console.log(`  Azure organization: ${organization}`);
+    console.log(`  Azure project: ${project}`);
+    if (repositoryUrlMessage) {
+        console.log(repositoryUrlMessage);
+    }
     if (gitRemoteMessage) {
         console.log(gitRemoteMessage);
     }
@@ -151,6 +206,107 @@ async function configureDevops(targetPath) {
         console.log("  Existing package.json already contained required entries.");
     }
 }
+async function configureVscode(targetPath) {
+    const targetDir = path.resolve(process.cwd(), targetPath ?? ".");
+    const templateDir = path.resolve(__dirname, "../templates/vscode");
+    try {
+        await access(templateDir);
+    }
+    catch (error) {
+        throw new Error("VS Code template directory is missing. Please ensure templates/vscode is available.");
+    }
+    const { copied, skipped } = await copyTemplateDirectory(templateDir, targetDir, targetDir);
+    console.log("\nVS Code configuration files processed.");
+    if (copied.length) {
+        console.log("  Added:");
+        for (const file of copied) {
+            console.log(`    ${file}`);
+        }
+    }
+    if (skipped.length) {
+        console.log("  Skipped (already exists):");
+        for (const file of skipped) {
+            console.log(`    ${file}`);
+        }
+    }
+    if (!copied.length && !skipped.length) {
+        console.log("  No files were found in the VS Code template directory.");
+    }
+}
+async function configureCodegen(targetPath) {
+    const targetDir = path.resolve(process.cwd(), targetPath ?? ".");
+    const templateDir = path.resolve(__dirname, "../templates/codegen");
+    const packagePath = path.join(targetDir, "package.json");
+    try {
+        await access(templateDir);
+    }
+    catch (error) {
+        throw new Error("GraphQL codegen template directory is missing. Please ensure templates/codegen is available.");
+    }
+    let pkgRaw;
+    try {
+        pkgRaw = await readFile(packagePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`Could not find package.json in ${targetDir}`);
+        }
+        throw error;
+    }
+    const pkg = JSON.parse(pkgRaw);
+    const { copied, skipped } = await copyTemplateDirectory(templateDir, targetDir, targetDir);
+    const devDeps = (pkg.devDependencies ??= {});
+    const deps = pkg.dependencies ?? {};
+    const requiredDevDeps = {
+        "@graphql-codegen/cli": "^5.0.7",
+        "@graphql-codegen/typescript": "^4.1.6",
+        "@graphql-codegen/typescript-operations": "^4.6.1",
+        "@graphql-codegen/typescript-resolvers": "^4.3.1",
+        "graphql": "^16.11.0",
+        "graphql-request": "^7.2.0"
+    };
+    let pkgChanged = false;
+    for (const [name, version] of Object.entries(requiredDevDeps)) {
+        if (!devDeps[name] && !deps[name]) {
+            devDeps[name] = version;
+            pkgChanged = true;
+        }
+    }
+    const scripts = (pkg.scripts ??= {});
+    if (!scripts.codegen) {
+        scripts.codegen = "graphql-code-generator --config codegen.ts";
+        pkgChanged = true;
+    }
+    if (!scripts["refresh-uns"]) {
+        scripts["refresh-uns"] = "node ./node_modules/@uns-kit/core/dist/tools/refresh-uns.js";
+        pkgChanged = true;
+    }
+    if (pkgChanged) {
+        await writeFile(packagePath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    }
+    console.log("\nGraphQL code generation setup complete.");
+    if (copied.length) {
+        console.log("  Added files:");
+        for (const file of copied) {
+            console.log(`    ${file}`);
+        }
+    }
+    if (skipped.length) {
+        console.log("  Skipped existing files:");
+        for (const file of skipped) {
+            console.log(`    ${file}`);
+        }
+    }
+    if (!copied.length && !skipped.length) {
+        console.log("  No template files were copied.");
+    }
+    if (pkgChanged) {
+        console.log("  Updated package.json scripts/devDependencies. Run pnpm install to fetch new packages.");
+    }
+    else {
+        console.log("  Existing package.json already contained required scripts and dependencies.");
+    }
+}
 async function ensureGitRepository(dir) {
     try {
         const { stdout } = await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], {
@@ -210,32 +366,194 @@ async function addGitRemote(dir, remoteName, remoteUrl) {
         throw new Error(`Failed to add git remote origin: ${error.message}`);
     }
 }
-function inferAzureOrganization(remoteUrl) {
+async function copyTemplateDirectory(sourceDir, targetDir, targetRoot) {
+    const entries = await readdir(sourceDir, { withFileTypes: true });
+    const copied = [];
+    const skipped = [];
+    for (const entry of entries) {
+        const sourcePath = path.join(sourceDir, entry.name);
+        const destinationPath = path.join(targetDir, entry.name);
+        const relativePath = path.relative(targetRoot, destinationPath) || entry.name;
+        if (entry.isDirectory()) {
+            await mkdir(destinationPath, { recursive: true });
+            const result = await copyTemplateDirectory(sourcePath, destinationPath, targetRoot);
+            copied.push(...result.copied);
+            skipped.push(...result.skipped);
+            continue;
+        }
+        if (entry.isFile()) {
+            await mkdir(path.dirname(destinationPath), { recursive: true });
+            if (await fileExists(destinationPath)) {
+                skipped.push(relativePath);
+                continue;
+            }
+            await copyFile(sourcePath, destinationPath);
+            copied.push(relativePath);
+        }
+    }
+    return { copied, skipped };
+}
+async function resolveAzureGitApi(organization) {
+    const tokensUrl = `https://dev.azure.com/${organization}/_usersSettings/tokens`;
+    const envPat = process.env.AZURE_PAT?.trim();
+    if (envPat) {
+        try {
+            const gitApi = await createAzureGitApi(organization, envPat);
+            console.log("Using PAT from AZURE_PAT environment variable.");
+            return { gitApi };
+        }
+        catch (error) {
+            console.log("The AZURE_PAT environment variable is invalid or expired. Please provide a new PAT.");
+        }
+    }
+    while (true) {
+        const input = (await promptQuestion(`Azure DevOps Personal Access Token (create at ${tokensUrl}): `)).trim();
+        if (!input) {
+            console.log("A Personal Access Token is required to create the repository.");
+            continue;
+        }
+        try {
+            const gitApi = await createAzureGitApi(organization, input);
+            return { gitApi };
+        }
+        catch (error) {
+            console.log("The provided PAT is invalid or expired. Please try again.");
+        }
+    }
+}
+async function createAzureGitApi(organization, personalAccessToken) {
+    const authHandler = azdev.getPersonalAccessTokenHandler(personalAccessToken);
+    const connection = new azdev.WebApi(`https://dev.azure.com/${organization}`, authHandler);
+    await connection.connect();
+    return connection.getGitApi();
+}
+async function ensureAzureRepositoryExists(gitApi, params) {
+    const repositoryName = params.repository.trim();
+    if (!repositoryName) {
+        throw new Error("Repository name is required.");
+    }
+    let existingRemoteUrl;
+    let existingWebUrl;
+    try {
+        const repositories = await gitApi.getRepositories(params.project);
+        const existing = repositories?.find((repo) => repo.name?.toLowerCase() === repositoryName.toLowerCase());
+        if (existing) {
+            existingRemoteUrl = existing.remoteUrl ?? undefined;
+            existingWebUrl = existing.webUrl ?? existingRemoteUrl;
+            return { remoteUrl: existingRemoteUrl, webUrl: existingWebUrl };
+        }
+    }
+    catch (error) {
+        // Fallback to attempting creation even if listing failed (e.g., limited permissions)
+    }
+    try {
+        const created = await gitApi.createRepository({ name: repositoryName }, params.project);
+        const remoteUrl = created?.remoteUrl ?? buildAzureGitRemoteUrl(params.organization, params.project, repositoryName);
+        const webUrl = created?.webUrl ?? created?.remoteUrl ?? buildAzureRepositoryUrl(params.organization, params.project, repositoryName);
+        console.log(`  Created Azure DevOps repository "${repositoryName}" in project "${params.project}".`);
+        return { remoteUrl, webUrl };
+    }
+    catch (error) {
+        try {
+            const repository = await gitApi.getRepository(repositoryName, params.project);
+            if (repository?.remoteUrl) {
+                return {
+                    remoteUrl: repository.remoteUrl,
+                    webUrl: repository.webUrl ?? repository.remoteUrl,
+                };
+            }
+        }
+        catch (lookupError) {
+            // Ignore lookup failure; we'll rethrow original error below.
+        }
+        const message = error.message || String(error);
+        throw new Error(`Failed to create Azure DevOps repository "${repositoryName}" in project "${params.project}": ${message}`);
+    }
+}
+function parseAzureRemote(remoteUrl) {
     try {
         const url = new URL(remoteUrl);
         const hostname = url.hostname.toLowerCase();
-        if (hostname === "dev.azure.com" || hostname.endsWith(".visualstudio.com")) {
-            const segments = url.pathname.split("/").filter(Boolean);
-            if (segments.length >= 1) {
-                return segments[0];
-            }
+        const segments = url.pathname.split("/").filter(Boolean);
+        if (hostname === "dev.azure.com") {
+            const organization = segments[0] || url.username || undefined;
+            const project = segments[1];
+            const repository = extractRepositoryFromSegments(segments.slice(2));
+            return {
+                organization: organization ? decodeURIComponent(organization) : undefined,
+                project: project ? decodeURIComponent(project) : undefined,
+                repository,
+            };
+        }
+        if (hostname.endsWith(".visualstudio.com")) {
+            const organization = hostname.replace(/\.visualstudio\.com$/, "");
+            const project = segments[0];
+            const repository = extractRepositoryFromSegments(segments.slice(1));
+            return {
+                organization,
+                project: project ? decodeURIComponent(project) : undefined,
+                repository,
+            };
         }
     }
     catch (error) {
-        // ignore parse errors for non-HTTP(S) remotes
+        // Non-HTTP remote (e.g., SSH)
     }
     if (remoteUrl.startsWith("git@ssh.dev.azure.com:")) {
         const [, pathPart] = remoteUrl.split(":", 2);
         if (pathPart) {
             const segments = pathPart.split("/").filter(Boolean);
             // Format: v3/{organization}/{project}/{repo}
-            if (segments.length >= 2) {
-                return segments[1];
+            if (segments[0]?.toLowerCase() === "v3") {
+                return {
+                    organization: segments[1] ? decodeURIComponent(segments[1]) : undefined,
+                    project: segments[2] ? decodeURIComponent(segments[2]) : undefined,
+                    repository: stripGitExtension(segments.slice(3).join("/")),
+                };
             }
         }
     }
     return undefined;
 }
+function extractRepositoryFromSegments(segments) {
+    if (!segments.length) {
+        return undefined;
+    }
+    if (segments[0] === "_git") {
+        return stripGitExtension(segments.slice(1).join("/"));
+    }
+    if (segments.length >= 2 && segments[1] === "_git") {
+        return stripGitExtension(segments.slice(2).join("/"));
+    }
+    return stripGitExtension(segments.join("/"));
+}
+function stripGitExtension(value) {
+    if (!value) {
+        return undefined;
+    }
+    return value.endsWith(".git") ? value.slice(0, -4) : value;
+}
+function encodeAzureSegment(segment) {
+    return encodeURIComponent(segment.trim());
+}
+function buildAzureGitRemoteUrl(organization, project, repository) {
+    const segments = [organization, project, "_git", repository].map(encodeAzureSegment);
+    return `https://dev.azure.com/${segments.join("/")}`;
+}
+function buildAzureRepositoryUrl(organization, project, repository) {
+    if (!organization || !project || !repository) {
+        return undefined;
+    }
+    return buildAzureGitRemoteUrl(organization, project, repository);
+}
+function inferRepositoryNameFromPackage(pkgName) {
+    if (typeof pkgName !== "string" || !pkgName.trim()) {
+        return "uns-app";
+    }
+    const trimmed = pkgName.trim();
+    const baseName = trimmed.startsWith("@") ? trimmed.split("/").pop() ?? trimmed : trimmed;
+    return baseName.replace(/[^A-Za-z0-9._-]+/g, "-");
+}
 function isGitRemoteMissingError(error) {
     if (!error || typeof error !== "object") {
         return false;
@@ -249,6 +567,18 @@ function isGitRemoteMissingError(error) {
 function isGitCommandNotFoundError(error) {
     return Boolean(error && typeof error === "object" && error.code === "ENOENT");
 }
+async function promptWithDefault(message, defaultValue, requiredMessage) {
+    while (true) {
+        const answer = (await promptQuestion(message)).trim();
+        if (answer) {
+            return answer;
+        }
+        if (defaultValue) {
+            return defaultValue;
+        }
+        console.log(requiredMessage);
+    }
+}
 async function promptQuestion(message) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     try {
@@ -258,6 +588,18 @@ async function promptQuestion(message) {
         rl.close();
     }
 }
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
 async function ensureTargetDir(dir) {
     try {
         const stats = await stat(dir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uns-kit/cli",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "Command line scaffolding tool for UNS applications",
   "type": "module",
   "license": "MIT",
@@ -25,7 +25,7 @@
     "templates"
   ],
   "dependencies": {
-    "@uns-kit/core": "0.0.16"
+    "@uns-kit/core": "0.0.19"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",

package/templates/codegen/codegen.ts

@@ -0,0 +1,15 @@
+import type { CodegenConfig } from '@graphql-codegen/cli';
+import { ConfigFile } from '@uns-kit/core';
+
+const appConfig = await ConfigFile.loadConfig();
+
+const config: CodegenConfig = {
+  schema: appConfig.uns.graphql,
+  generates: {
+    'src/graphql/schema.ts': {
+      plugins: ['typescript', 'typescript-operations', 'typescript-resolvers'],
+    },
+  },
+};
+
+export default config;

package/templates/codegen/src/uns/uns-tags.ts

@@ -0,0 +1 @@
+export type UnsTags = string & {};

package/templates/codegen/src/uns/uns-topics.ts

@@ -0,0 +1 @@
+export type UnsTopics = string & {};

package/templates/default/README.md

@@ -9,6 +9,8 @@ pnpm run dev    # start the local development loop
 pnpm run build  # emit dist/ output
 pnpm run start  # run the compiled entrypoint
 pnpm run generate-config-schema  # regenerate config.schema.json and AppConfig types
+pnpm run codegen            # regenerate typed GraphQL operations (after configure-codegen)
+pnpm run refresh-uns        # rebuild UNS topics/tags from the live schema
 ```
 
 ## Configuration
@@ -21,4 +23,6 @@ Update `config.json` with your broker, UNS URLs, and credentials. The generated
 - Create MQTT proxies or Temporal workflows inside `src/index.ts`.
 - Extend `src/config/project.config.extension.ts` with project-specific sections and run `pnpm run generate-config-schema`.
 - Run `uns-kit configure-devops` to add the Azure DevOps pull-request tooling.
+- Run `uns-kit configure-vscode` to copy workspace/launch configuration for VS Code.
+- Run `uns-kit configure-codegen` to scaffold GraphQL code generation and UNS refresh scripts.
 - Commit your new project and start building!

package/templates/default/config.json

@@ -18,6 +18,8 @@
     "host": "localhost:1883"
   },
   "devops": {
-    "organization": "sijit"
+    "provider": "azure-devops",
+    "organization": "sijit",
+    "project": "industry40"
   }
 }

package/templates/default/src/uns/uns-tags.ts

@@ -0,0 +1,2 @@
+// Generated UNS tag union. Run `pnpm refresh-uns` to update.
+export type UnsTags = string & {};

package/templates/default/src/uns/uns-topics.ts

@@ -0,0 +1,2 @@
+// Generated UNS topic union. Run `pnpm refresh-uns` to update.
+export type UnsTopics = string & {};

package/templates/vscode/.vscode/launch.json

@@ -0,0 +1,22 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "uns-kit: dev",
+      "runtimeArgs": [
+        "--enable-source-maps",
+        "--import",
+        "tsx"
+      ],
+      "program": "${workspaceFolder}/src/index.ts",
+      "cwd": "${workspaceFolder}",
+      "sourceMaps": true,
+      "skipFiles": ["<node_internals>/**"],
+      "resolveSourceMapLocations": [
+        "${workspaceFolder}/**"
+      ]
+    }
+  ]
+}

package/templates/vscode/uns-kit.code-workspace

@@ -0,0 +1,13 @@
+{
+  "folders": [
+    {
+      "path": "."
+    }
+  ],
+  "settings": {
+    "files.exclude": {
+      "dist": true,
+      "node_modules": true
+    }
+  }
+}

package/templates/default/uns-library.json

@@ -1,4 +0,0 @@
-{
-  "name": "template-uns-rtt",
-  "version": "2.0.0"
-}