@uns-kit/cli 0.0.12 → 0.0.14

package/dist/index.js

@@ -1,14 +1,19 @@
 #!/usr/bin/env node
-import { access, cp, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+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];
@@ -27,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) {
@@ -48,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);
@@ -91,13 +124,47 @@ async function configureDevops(targetPath) {
     }
     const pkg = JSON.parse(pkgRaw);
     const config = JSON.parse(configRaw);
-    const defaultOrg = config.devops?.organization ?? "sijit";
-    const answer = (await promptQuestion(`Azure DevOps organization [${defaultOrg}]: `)).trim();
-    const organization = answer || defaultOrg;
+    await ensureGitRepository(targetDir);
+    const remoteUrl = await getGitRemoteUrl(targetDir, "origin");
+    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",
@@ -123,7 +190,15 @@ 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);
+    }
     if (pkgChanged) {
         console.log("  Updated package.json scripts/devDependencies. Run pnpm install to fetch new packages.");
     }
@@ -131,6 +206,379 @@ 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"], {
+            cwd: dir,
+            encoding: "utf8",
+        });
+        if (stdout.trim() !== "true") {
+            throw new Error(`Directory ${dir} is not a git repository.`);
+        }
+    }
+    catch (error) {
+        if (isGitCommandNotFoundError(error)) {
+            throw new Error("Git is required to run configure-devops but was not found in PATH.");
+        }
+        const execError = error;
+        const stderr = typeof execError.stderr === "string" ? execError.stderr : "";
+        if (stderr.includes("not a git repository")) {
+            throw new Error(`Directory ${dir} is not a git repository.`);
+        }
+        throw error;
+    }
+}
+async function getGitRemoteUrl(dir, remoteName) {
+    try {
+        const { stdout } = await execFileAsync("git", ["remote", "get-url", remoteName], {
+            cwd: dir,
+            encoding: "utf8",
+        });
+        return stdout.trim();
+    }
+    catch (error) {
+        if (isGitCommandNotFoundError(error)) {
+            throw new Error("Git is required to run configure-devops but was not found in PATH.");
+        }
+        if (isGitRemoteMissingError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+async function addGitRemote(dir, remoteName, remoteUrl) {
+    try {
+        await execFileAsync("git", ["remote", "add", remoteName, remoteUrl], {
+            cwd: dir,
+            encoding: "utf8",
+        });
+    }
+    catch (error) {
+        if (isGitCommandNotFoundError(error)) {
+            throw new Error("Git is required to run configure-devops but was not found in PATH.");
+        }
+        const execError = error;
+        const stderr = typeof execError.stderr === "string" ? execError.stderr.trim() : "";
+        if (stderr) {
+            throw new Error(`Failed to add git remote origin: ${stderr}`);
+        }
+        throw new Error(`Failed to add git remote origin: ${error.message}`);
+    }
+}
+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();
+        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) {
+        // 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[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;
+    }
+    const execError = error;
+    if (typeof execError.stderr === "string") {
+        return execError.stderr.includes("No such remote");
+    }
+    return false;
+}
+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 {
@@ -140,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.12",
+  "version": "0.0.14",
   "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.18"
   },
   "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/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"
-}