czon 0.8.0 → 0.8.2

package/dist/commands/config-github.js

@@ -35,44 +35,328 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigGithubCommand = void 0;
 const clipanion_1 = require("clipanion");
+const prompts_1 = require("@inquirer/prompts");
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const writeFile_1 = require("../utils/writeFile");
+const git = __importStar(require("../utils/git"));
+const github = __importStar(require("../utils/github"));
 class ConfigGithubCommand extends clipanion_1.Command {
     async execute() {
+        const stdout = this.context.stdout;
+        const stderr = this.context.stderr;
+        // ========== Step 0: Prerequisites check ==========
+        stdout.write('Checking prerequisites...\n');
+        // Check gh CLI installation
+        if (!github.isGhInstalled()) {
+            stderr.write('\nGitHub CLI (gh) is not installed.\n' +
+                'Please install it from: https://cli.github.com/\n');
+            return 1;
+        }
+        // Check gh authentication
+        if (!github.isGhAuthenticated()) {
+            stderr.write('\nGitHub CLI is not authenticated.\n' + 'Please run: gh auth login\n');
+            return 1;
+        }
+        // Check required token scopes
+        const requiredScopes = ['repo'];
+        const { hasScopes, missingScopes, currentScopes } = github.checkTokenScopes(requiredScopes);
+        if (!hasScopes) {
+            stderr.write('\nGitHub CLI token is missing required permissions.\n' +
+                `  Current scopes: ${currentScopes.length > 0 ? currentScopes.join(', ') : '(none detected)'}\n` +
+                `  Missing scopes: ${missingScopes.join(', ')}\n\n` +
+                'Please re-authenticate with the required scopes:\n' +
+                '  gh auth login --scopes repo\n\n' +
+                'Or refresh your existing token:\n' +
+                '  gh auth refresh --scopes repo\n');
+            return 1;
+        }
+        stdout.write('GitHub CLI detected and authenticated.\n\n');
+        // ========== Step 1: Git repository check ==========
+        if (!git.isGitRepository()) {
+            const shouldInit = await (0, prompts_1.confirm)({
+                message: 'Current directory is not a Git repository. Initialize one?',
+                default: true,
+            });
+            if (!shouldInit) {
+                stdout.write('Aborted.\n');
+                return 0;
+            }
+            git.initGitRepository();
+            stdout.write('Git repository initialized.\n\n');
+        }
+        // ========== Step 2: Remote repository configuration ==========
+        const remotes = git.getRemotes();
+        const githubRemotes = remotes.filter(r => github.isGitHubUrl(r.fetchUrl));
+        let selectedRemote;
+        if (githubRemotes.length === 0) {
+            // No GitHub remote found
+            stdout.write('No GitHub remote repository found.\n');
+            const action = await (0, prompts_1.select)({
+                message: 'What would you like to do?',
+                choices: [
+                    { name: 'Create a new GitHub repository', value: 'create' },
+                    {
+                        name: 'Add an existing GitHub repository URL',
+                        value: 'add',
+                    },
+                ],
+            });
+            if (action === 'create') {
+                // Create new repository
+                const repoName = await (0, prompts_1.input)({
+                    message: 'Repository name:',
+                    default: path.basename(process.cwd()),
+                });
+                const isPrivate = await (0, prompts_1.confirm)({
+                    message: 'Make repository private?',
+                    default: false,
+                });
+                stdout.write('Creating GitHub repository...\n');
+                const { owner, repo, url } = github.createRepository({
+                    name: repoName,
+                    private: isPrivate,
+                });
+                // Determine remote name
+                let remoteName = 'origin';
+                if (git.remoteExists('origin')) {
+                    remoteName = await (0, prompts_1.input)({
+                        message: 'Remote "origin" already exists. Enter a name for the GitHub remote:',
+                        default: 'github',
+                    });
+                }
+                git.addRemote(remoteName, url);
+                selectedRemote = { name: remoteName, owner, repo };
+                stdout.write(`Repository created: https://github.com/${owner}/${repo}\n`);
+                stdout.write(`Added as remote "${remoteName}".\n\n`);
+            }
+            else {
+                // Add existing repository
+                const repoUrl = await (0, prompts_1.input)({
+                    message: 'GitHub repository URL:',
+                    validate: value => {
+                        if (!github.isGitHubUrl(value)) {
+                            return 'Please enter a valid GitHub repository URL';
+                        }
+                        return true;
+                    },
+                });
+                const parsed = github.parseGitHubUrl(repoUrl);
+                // Determine remote name
+                let remoteName = 'origin';
+                if (git.remoteExists('origin')) {
+                    remoteName = await (0, prompts_1.input)({
+                        message: 'Remote "origin" already exists. Enter a name for the GitHub remote:',
+                        default: 'github',
+                    });
+                }
+                git.addRemote(remoteName, repoUrl);
+                selectedRemote = {
+                    name: remoteName,
+                    owner: parsed.owner,
+                    repo: parsed.repo,
+                };
+                stdout.write(`Remote "${remoteName}" added.\n\n`);
+            }
+        }
+        else if (githubRemotes.length === 1) {
+            // Single GitHub remote
+            const remote = githubRemotes[0];
+            const parsed = github.parseGitHubUrl(remote.fetchUrl);
+            selectedRemote = {
+                name: remote.name,
+                owner: parsed.owner,
+                repo: parsed.repo,
+            };
+            stdout.write(`Using GitHub remote "${remote.name}" (${parsed.owner}/${parsed.repo}).\n\n`);
+        }
+        else {
+            // Multiple GitHub remotes - ask user to choose
+            const choices = githubRemotes.map(r => {
+                const parsed = github.parseGitHubUrl(r.fetchUrl);
+                return {
+                    name: `${r.name} (${parsed.owner}/${parsed.repo})`,
+                    value: r.name,
+                };
+            });
+            const selectedName = await (0, prompts_1.select)({
+                message: 'Multiple GitHub remotes found. Which one to configure?',
+                choices,
+            });
+            const remote = githubRemotes.find(r => r.name === selectedName);
+            const parsed = github.parseGitHubUrl(remote.fetchUrl);
+            selectedRemote = {
+                name: remote.name,
+                owner: parsed.owner,
+                repo: parsed.repo,
+            };
+            stdout.write('\n');
+        }
+        stdout.write(`Configuring GitHub Pages for ${selectedRemote.owner}/${selectedRemote.repo}...\n`);
+        // ========== Step 3: GitHub Pages configuration ==========
+        let pagesInfo;
         try {
-            const targetDir = process.cwd();
-            const templatePath = path.join(__dirname, '..', '..', 'templates', 'pages.yml');
-            const targetPath = path.join(targetDir, '.github', 'workflows', 'pages.yml');
-            // 检查模板文件是否存在
+            pagesInfo = github.getPagesInfo(selectedRemote.owner, selectedRemote.repo);
+        }
+        catch (error) {
+            stderr.write(`\nFailed to get GitHub Pages info: ${error}\n` +
+                'You may need to enable Pages manually in repository settings.\n');
+            pagesInfo = { enabled: false };
+        }
+        if (!pagesInfo.enabled || pagesInfo.buildType !== 'workflow') {
+            stdout.write('Enabling GitHub Pages with workflow deployment...\n');
             try {
-                await fs.access(templatePath);
+                github.enablePages(selectedRemote.owner, selectedRemote.repo);
+                stdout.write('GitHub Pages enabled.\n');
             }
-            catch {
-                this.context.stderr.write(`Template file not found: ${templatePath}\n`);
-                return 1;
+            catch (error) {
+                stderr.write(`\nFailed to enable GitHub Pages: ${error}\n` +
+                    'You may need to enable Pages manually:\n' +
+                    `  https://github.com/${selectedRemote.owner}/${selectedRemote.repo}/settings/pages\n` +
+                    '  Set "Build and deployment" source to "GitHub Actions"\n\n');
             }
-            // 读取模板文件
-            const content = await fs.readFile(templatePath, 'utf-8');
-            // 确保目标目录存在并写入文件
-            await (0, writeFile_1.writeFile)(targetPath, content);
-            this.context.stdout.write(`GitHub Actions workflow copied to ${targetPath}\n`);
-            return 0;
         }
-        catch (error) {
-            this.context.stderr.write(`Failed to copy workflow template: ${error}\n`);
+        else {
+            stdout.write('GitHub Pages is already configured for workflow deployment.\n');
+        }
+        // CNAME configuration
+        const configureCname = await (0, prompts_1.confirm)({
+            message: 'Do you want to configure a custom domain (CNAME)?',
+            default: false,
+        });
+        if (configureCname) {
+            const cname = await (0, prompts_1.input)({
+                message: 'Enter your custom domain (e.g., docs.example.com):',
+                validate: value => {
+                    if (!value || !/^[a-zA-Z0-9][a-zA-Z0-9-_.]*[a-zA-Z0-9]$/.test(value)) {
+                        return 'Please enter a valid domain name';
+                    }
+                    return true;
+                },
+            });
+            try {
+                github.setPagesCname(selectedRemote.owner, selectedRemote.repo, cname);
+                stdout.write(`Custom domain set to: ${cname}\n`);
+            }
+            catch (error) {
+                stderr.write(`\nFailed to set custom domain: ${error}\n` +
+                    'You can set it manually in repository settings.\n');
+            }
+        }
+        stdout.write('\n');
+        // ========== Step 4: Workflow file management ==========
+        const workflowRelativePath = '.github/workflows/pages.yml';
+        const workflowPath = path.join(process.cwd(), workflowRelativePath);
+        const templatePath = path.join(__dirname, '..', '..', 'templates', 'pages.yml');
+        let templateContent;
+        try {
+            templateContent = await fs.readFile(templatePath, 'utf-8');
+        }
+        catch {
+            stderr.write(`Template file not found: ${templatePath}\n`);
             return 1;
         }
+        let workflowNeedsWrite = false;
+        let workflowExists = false;
+        try {
+            const existingContent = await fs.readFile(workflowPath, 'utf-8');
+            workflowExists = true;
+            if (existingContent !== templateContent) {
+                const shouldUpdate = await (0, prompts_1.confirm)({
+                    message: 'Workflow file exists but differs from template. Update it?',
+                    default: true,
+                });
+                if (shouldUpdate) {
+                    workflowNeedsWrite = true;
+                }
+                else {
+                    stdout.write('Keeping existing workflow file.\n');
+                }
+            }
+            else {
+                stdout.write('Workflow file is up to date.\n');
+            }
+        }
+        catch {
+            // File doesn't exist
+            workflowNeedsWrite = true;
+        }
+        if (workflowNeedsWrite) {
+            await (0, writeFile_1.writeFile)(workflowPath, templateContent);
+            stdout.write(workflowExists ? 'Workflow file updated.\n' : 'Workflow file created.\n');
+        }
+        // ========== Step 5: Commit and push ==========
+        const hasWorkflowChanges = git.hasChanges(workflowRelativePath) || git.isUntracked(workflowRelativePath);
+        if (hasWorkflowChanges) {
+            const shouldCommit = await (0, prompts_1.confirm)({
+                message: 'Commit and push the workflow file?',
+                default: true,
+            });
+            if (shouldCommit) {
+                try {
+                    git.stageFiles([workflowRelativePath]);
+                    git.commit('chore: add GitHub Pages deployment workflow');
+                    const branch = git.getCurrentBranch() || git.getDefaultBranch();
+                    stdout.write(`Pushing to ${selectedRemote.name}/${branch}...\n`);
+                    git.push(selectedRemote.name, branch, { setUpstream: true });
+                    stdout.write('Changes committed and pushed.\n');
+                }
+                catch (error) {
+                    stderr.write(`\nFailed to commit/push: ${error}\n`);
+                    stderr.write('You can manually commit and push the workflow file:\n' +
+                        `  git add ${workflowRelativePath}\n` +
+                        '  git commit -m "chore: add GitHub Pages deployment workflow"\n' +
+                        `  git push -u ${selectedRemote.name} <branch>\n`);
+                }
+            }
+        }
+        else {
+            stdout.write('No changes to commit.\n');
+        }
+        // ========== Step 6: Show result ==========
+        let pagesUrl = null;
+        try {
+            pagesUrl = github.getPagesUrl(selectedRemote.owner, selectedRemote.repo);
+        }
+        catch {
+            // Ignore error
+        }
+        stdout.write('\n');
+        stdout.write('========================================\n');
+        stdout.write('GitHub Pages configuration complete!\n');
+        stdout.write('========================================\n');
+        if (pagesUrl) {
+            stdout.write(`\nYour site will be available at:\n  ${pagesUrl}\n`);
+        }
+        else {
+            stdout.write('\nYour site URL will be available after the first deployment.\n' +
+                `Check: https://github.com/${selectedRemote.owner}/${selectedRemote.repo}/settings/pages\n`);
+        }
+        stdout.write('\nThe workflow will automatically deploy on:\n' +
+            '  - Push to main branch\n' +
+            '  - Every hour (scheduled)\n' +
+            '  - Manual trigger from Actions tab\n');
+        return 0;
     }
 }
 exports.ConfigGithubCommand = ConfigGithubCommand;
 ConfigGithubCommand.paths = [['config', 'github']];
 ConfigGithubCommand.usage = clipanion_1.Command.Usage({
-    description: 'Copy GitHub Pages deployment workflow template to .github/workflows/pages.yml',
+    description: 'Configure GitHub Pages deployment for your CZON site',
     details: `
-      This command copies the GitHub Pages deployment workflow template (templates/pages.yml)
-      to the current directory's .github/workflows/pages.yml location.
-
+      This command guides you through setting up GitHub Pages deployment:
+      
+      1. Initialize Git repository (if needed)
+      2. Configure GitHub remote repository
+      3. Enable GitHub Pages with workflow deployment
+      4. Create/update the deployment workflow file
+      5. Commit and push changes
+      
+      Prerequisites:
+        - GitHub CLI (gh) must be installed and authenticated
+        - Install: https://cli.github.com/
+        - Login: gh auth login
+      
       Examples:
         $ czon config github
     `,

package/dist/process/extractMetadataByAI.js

@@ -4,6 +4,7 @@ exports.extractMetadataByAI = extractMetadataByAI;
 const promises_1 = require("fs/promises");
 const extractMetadataFromMarkdown_1 = require("../ai/extractMetadataFromMarkdown");
 const metadata_1 = require("../metadata");
+const sha256_1 = require("../utils/sha256");
 /**
  * 运行 AI 元数据提取
  */
@@ -16,12 +17,19 @@ async function extractMetadataByAI() {
             console.info(`ℹ️ Skipping ${file.path}, not a Markdown file`);
             return;
         }
-        if (file.metadata && file.metadata.slug && file.metadata.short_summary) {
-            console.info(`ℹ️ Skipping ${file.path}, already has metadata`);
+        const content = await (0, promises_1.readFile)(file.path, 'utf-8');
+        const hash = (0, sha256_1.sha256)(content);
+        // 检查是否已有 metadata 且源文件未变化
+        if (file.metadata &&
+            file.metadata.slug &&
+            file.metadata.short_summary &&
+            hash === file.hash) {
+            console.info(`ℹ️ Skipping ${file.path}, already has metadata and content unchanged`);
             return;
         }
-        const content = await (0, promises_1.readFile)(file.path, 'utf-8');
         file.metadata = await (0, extractMetadataFromMarkdown_1.extractMetadataFromMarkdown)(file.path, content);
+        // 记录提取 metadata 时的源文件 hash
+        file.hash = hash;
         console.log(`✅ Extracted AI metadata for ${file.path}`, file.metadata.tokens_used);
     }));
     const errors = results.filter(r => r.status === 'rejected');

package/dist/process/scanSourceFiles.js

@@ -9,7 +9,6 @@ const path_1 = __importDefault(require("path"));
 const findEntries_1 = require("../findEntries");
 const metadata_1 = require("../metadata");
 const paths_1 = require("../paths");
-const sha256_1 = require("../utils/sha256");
 const extractLinksFromMarkdown = (content) => {
     const linkRegex = /\[.*?\]\((.*?)\)/g;
     const links = [];
@@ -50,21 +49,17 @@ async function scanSourceFiles() {
             continue;
         }
         const contentBuffer = await (0, promises_1.readFile)(fullPath);
-        const hash = (0, sha256_1.sha256)(contentBuffer);
         paths.add(relativePath);
         let meta = metadata_1.MetaData.files.find(f => f.path === relativePath);
         if (!meta) {
-            meta = { hash, path: relativePath, links: [] };
+            meta = { path: relativePath, links: [] };
             metadata_1.MetaData.files.push(meta);
         }
-        else {
-            meta.hash = hash;
-        }
         // 处理 Markdown 文件
         if (fullPath.endsWith('.md')) {
             const content = contentBuffer.toString('utf-8');
             const links = extractLinksFromMarkdown(content);
-            console.info(`  - Found file: ${relativePath} (hash: ${hash})`);
+            console.info(`  - Found file: ${relativePath}`);
             console.info(`    Links: ${links.join(', ') || 'None'}`);
             meta.links = links;
             for (const link of links) {

package/dist/utils/git.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGitRepository = isGitRepository;
+exports.initGitRepository = initGitRepository;
+exports.getRemotes = getRemotes;
+exports.addRemote = addRemote;
+exports.remoteExists = remoteExists;
+exports.getCurrentBranch = getCurrentBranch;
+exports.getDefaultBranch = getDefaultBranch;
+exports.stageFiles = stageFiles;
+exports.commit = commit;
+exports.push = push;
+exports.hasChanges = hasChanges;
+exports.isUntracked = isUntracked;
+const child_process_1 = require("child_process");
+/**
+ * Execute a git command and return the output
+ * @throws Error if the command fails
+ */
+function execGit(args, options) {
+    const command = ['git', ...args].join(' ');
+    try {
+        return (0, child_process_1.execSync)(command, {
+            cwd: options?.cwd ?? process.cwd(),
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(err.stderr || err.message || 'Git command failed');
+    }
+}
+/**
+ * Check if the current directory is a Git repository
+ */
+function isGitRepository() {
+    try {
+        execGit(['rev-parse', '--is-inside-work-tree']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Initialize a new Git repository
+ */
+function initGitRepository() {
+    execGit(['init']);
+}
+/**
+ * Get all remote repositories
+ */
+function getRemotes() {
+    try {
+        const output = execGit(['remote', '-v']);
+        if (!output)
+            return [];
+        const lines = output.split('\n');
+        const remoteMap = new Map();
+        for (const line of lines) {
+            const match = line.match(/^(\S+)\s+(\S+)\s+\((fetch|push)\)$/);
+            if (match) {
+                const [, name, url, type] = match;
+                if (!remoteMap.has(name)) {
+                    remoteMap.set(name, { name, fetchUrl: '', pushUrl: '' });
+                }
+                const remote = remoteMap.get(name);
+                if (type === 'fetch') {
+                    remote.fetchUrl = url;
+                }
+                else {
+                    remote.pushUrl = url;
+                }
+            }
+        }
+        return Array.from(remoteMap.values());
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Add a remote repository
+ */
+function addRemote(name, url) {
+    execGit(['remote', 'add', name, url]);
+}
+/**
+ * Check if a remote exists
+ */
+function remoteExists(name) {
+    const remotes = getRemotes();
+    return remotes.some(r => r.name === name);
+}
+/**
+ * Get the current branch name
+ */
+function getCurrentBranch() {
+    try {
+        return execGit(['rev-parse', '--abbrev-ref', 'HEAD']);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the default branch name (main or master)
+ */
+function getDefaultBranch() {
+    try {
+        // Try to get the default branch from git config
+        const defaultBranch = execGit(['config', '--get', 'init.defaultBranch']);
+        if (defaultBranch)
+            return defaultBranch;
+    }
+    catch {
+        // Ignore error
+    }
+    // Check if main branch exists
+    try {
+        execGit(['rev-parse', '--verify', 'main']);
+        return 'main';
+    }
+    catch {
+        // Ignore error
+    }
+    // Check if master branch exists
+    try {
+        execGit(['rev-parse', '--verify', 'master']);
+        return 'master';
+    }
+    catch {
+        // Ignore error
+    }
+    // Default to main
+    return 'main';
+}
+/**
+ * Stage files for commit
+ */
+function stageFiles(files) {
+    execGit(['add', ...files]);
+}
+/**
+ * Commit staged changes
+ */
+function commit(message) {
+    execGit(['commit', '-m', message]);
+}
+/**
+ * Push to remote repository
+ */
+function push(remote, branch, options) {
+    const args = ['push'];
+    if (options?.setUpstream) {
+        args.push('-u');
+    }
+    args.push(remote, branch);
+    execGit(args);
+}
+/**
+ * Check if a file has uncommitted changes (staged or unstaged)
+ */
+function hasChanges(file) {
+    try {
+        // Check for both staged and unstaged changes
+        const status = execGit(['status', '--porcelain', file]);
+        return status.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a file is untracked
+ */
+function isUntracked(file) {
+    try {
+        const status = execGit(['status', '--porcelain', file]);
+        return status.startsWith('??');
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=git.js.map

package/dist/utils/github.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGhInstalled = isGhInstalled;
+exports.isGhAuthenticated = isGhAuthenticated;
+exports.getTokenScopes = getTokenScopes;
+exports.checkTokenScopes = checkTokenScopes;
+exports.parseGitHubUrl = parseGitHubUrl;
+exports.isGitHubUrl = isGitHubUrl;
+exports.createRepository = createRepository;
+exports.getPagesInfo = getPagesInfo;
+exports.enablePages = enablePages;
+exports.setPagesCname = setPagesCname;
+exports.getPagesUrl = getPagesUrl;
+exports.getAuthenticatedUser = getAuthenticatedUser;
+const child_process_1 = require("child_process");
+/**
+ * Execute a gh CLI command and return the output
+ * Uses spawnSync to avoid shell parsing issues with special characters
+ * @throws Error if the command fails
+ */
+function execGh(args) {
+    const result = (0, child_process_1.spawnSync)('gh', args, {
+        cwd: process.cwd(),
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        throw new Error(result.stderr || `gh command failed with exit code ${result.status}`);
+    }
+    return (result.stdout || '').trim();
+}
+/**
+ * Check if GitHub CLI (gh) is installed
+ */
+function isGhInstalled() {
+    try {
+        (0, child_process_1.execSync)('gh --version', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if GitHub CLI is authenticated
+ */
+function isGhAuthenticated() {
+    try {
+        execGh(['auth', 'status']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the token scopes for the current GitHub CLI authentication
+ * @returns Array of scope strings, or empty array if unable to determine
+ */
+function getTokenScopes() {
+    try {
+        const result = (0, child_process_1.spawnSync)('gh', ['auth', 'status'], {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // gh auth status outputs to stderr
+        const output = result.stderr || result.stdout || '';
+        // Parse token scopes from output
+        // Format: "- Token scopes: 'scope1', 'scope2', 'scope3'"
+        const scopesMatch = output.match(/Token scopes:\s*(.+)/);
+        if (scopesMatch) {
+            const scopesStr = scopesMatch[1];
+            // Extract scopes from quoted strings like 'repo', 'workflow'
+            const scopes = scopesStr.match(/'([^']+)'/g);
+            if (scopes) {
+                return scopes.map(s => s.replace(/'/g, ''));
+            }
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check if the current authentication has the required scopes
+ * @param requiredScopes Array of required scope names
+ * @returns Object with hasScopes boolean and missingScopes array
+ */
+function checkTokenScopes(requiredScopes) {
+    const currentScopes = getTokenScopes();
+    const missingScopes = requiredScopes.filter(required => !currentScopes.includes(required));
+    return {
+        hasScopes: missingScopes.length === 0,
+        missingScopes,
+        currentScopes,
+    };
+}
+/**
+ * Parse a GitHub URL and extract owner and repo
+ * Supports formats:
+ * - https://github.com/owner/repo.git
+ * - https://github.com/owner/repo
+ * - git@github.com:owner/repo.git
+ * - git@github.com:owner/repo
+ */
+function parseGitHubUrl(url) {
+    // HTTPS format
+    const httpsMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/.]+)(?:\.git)?$/);
+    if (httpsMatch) {
+        return { owner: httpsMatch[1], repo: httpsMatch[2] };
+    }
+    // SSH format
+    const sshMatch = url.match(/^git@github\.com:([^/]+)\/([^/.]+)(?:\.git)?$/);
+    if (sshMatch) {
+        return { owner: sshMatch[1], repo: sshMatch[2] };
+    }
+    return null;
+}
+/**
+ * Check if a URL is a GitHub repository URL
+ */
+function isGitHubUrl(url) {
+    return parseGitHubUrl(url) !== null;
+}
+/**
+ * Create a new GitHub repository
+ */
+function createRepository(options) {
+    const args = ['repo', 'create', options.name, '--confirm'];
+    if (options.private) {
+        args.push('--private');
+    }
+    else {
+        args.push('--public');
+    }
+    if (options.description) {
+        args.push('--description', options.description);
+    }
+    const output = execGh(args);
+    // Parse the output to get the repo URL
+    // Output format: https://github.com/owner/repo
+    const urlMatch = output.match(/https:\/\/github\.com\/([^/]+)\/([^\s]+)/);
+    if (!urlMatch) {
+        throw new Error('Failed to parse repository URL from gh output');
+    }
+    const owner = urlMatch[1];
+    const repo = urlMatch[2];
+    return {
+        owner,
+        repo,
+        url: `https://github.com/${owner}/${repo}.git`,
+        isPrivate: options.private ?? false,
+    };
+}
+/**
+ * Get GitHub Pages configuration for a repository
+ */
+function getPagesInfo(owner, repo) {
+    try {
+        const output = execGh([
+            'api',
+            `repos/${owner}/${repo}/pages`,
+            '--jq',
+            '{ url: .html_url, build_type: .build_type, cname: .cname }',
+        ]);
+        const data = JSON.parse(output);
+        return {
+            enabled: true,
+            url: data.url,
+            buildType: data.build_type,
+            cname: data.cname,
+        };
+    }
+    catch (error) {
+        const err = error;
+        // 404 means Pages is not enabled
+        if (err.message?.includes('404')) {
+            return { enabled: false };
+        }
+        throw error;
+    }
+}
+/**
+ * Enable GitHub Pages with workflow deployment
+ */
+function enablePages(owner, repo) {
+    try {
+        // Try to create/enable Pages with workflow build type
+        execGh(['api', `repos/${owner}/${repo}/pages`, '-X', 'POST', '-f', 'build_type=workflow']);
+    }
+    catch (error) {
+        const err = error;
+        // If Pages already exists, update it
+        if (err.message?.includes('409') || err.message?.includes('already')) {
+            execGh(['api', `repos/${owner}/${repo}/pages`, '-X', 'PUT', '-f', 'build_type=workflow']);
+        }
+        else {
+            throw error;
+        }
+    }
+}
+/**
+ * Set custom domain (CNAME) for GitHub Pages
+ */
+function setPagesCname(owner, repo, cname) {
+    if (cname) {
+        execGh(['api', `repos/${owner}/${repo}/pages`, '-X', 'PUT', '-f', `cname=${cname}`]);
+    }
+    else {
+        // Remove CNAME by setting it to empty
+        execGh(['api', `repos/${owner}/${repo}/pages`, '-X', 'PUT', '-f', 'cname=']);
+    }
+}
+/**
+ * Get the GitHub Pages URL for a repository
+ */
+function getPagesUrl(owner, repo) {
+    try {
+        const output = execGh(['api', `repos/${owner}/${repo}/pages`, '--jq', '.html_url']);
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the authenticated user's login name
+ */
+function getAuthenticatedUser() {
+    return execGh(['api', 'user', '--jq', '.login']);
+}
+//# sourceMappingURL=github.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "czon",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "CZON - AI enhanced Markdown content engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,6 +50,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
     "@opencode-ai/sdk": "^1.1.34",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",