repo-starter-kit 0.1.1

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2025-present Baptiste Augrain
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+[@zokugun/repo-starter-kit](https://github.com/zokugun/repo-starter-kit)
+========================================================================
+
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+[![NPM Version](https://img.shields.io/npm/v/@zokugun/repo-starter-kit.svg?colorB=green)](https://www.npmjs.com/package/@zokugun/repo-starter-kit)
+[![Donation](https://img.shields.io/badge/donate-ko--fi-green)](https://ko-fi.com/daiyam)
+[![Donation](https://img.shields.io/badge/donate-liberapay-green)](https://liberapay.com/daiyam/donate)
+[![Donation](https://img.shields.io/badge/donate-paypal-green)](https://paypal.me/daiyam99)
+
+
+Command-line helper to bootstrap and sync repository settings (labels, issues and basic config) from a reusable package or local files.
+
+Why use this tool?
+
+- Reuse a central `repo-starter-kit` configuration published as an npm package or provide local files to keep repositories consistent.
+- Manage issue templates and labels programmatically.
+- Lightweight CLI with interactive prompts when needed.
+
+Quick start
+-----------
+
+Install globally with npm:
+
+```bash
+npm install -g @zokugun/repo-starter-kit
+```
+
+Or run directly with npx:
+
+```bash
+npx @zokugun/repo-starter-kit --repo owner/name --package @your/package
+```
+
+Usage
+-----
+
+Basic example:
+
+```bash
+repo-starter-kit --repo daiyam/temp --package @daiyam/default --keep-labels
+```
+
+Options
+-------
+
+- `-r, --repo <owner/name>`: Target repository (OWNER/NAME). Required.
+- `-l, --labels <path>`: Path to a labels YAML file to apply to the repository.
+- `-i, --issue <path>`: Path to a Markdown file used as an issue template.
+- `-p, --package <name>`: An npm package that includes a `repo-starter-kit` configuration file to apply.
+- `-k, --keep-labels`: Do not delete labels missing from the provided configuration (defaults to false).
+- `-v, --version`: Show version number.
+
+Examples
+--------
+
+- Apply a published starter package to a repository:
+
+```bash
+repo-starter-kit -r myuser/myrepo -p @myorg/myconfig
+```
+
+- Apply local labels file and an issue template (do not remove existing labels):
+
+```bash
+repo-starter-kit -r myuser/myrepo -l labels.yml -i issue.md -k
+```
+
+Configuration package
+---------------------
+
+The configuration package need to be prefixed:
+- `--package @daiyam/default` will load the package `@daiyam/repo-starter-kit-default`
+
+At its root, it needs to have one of the following file:
+- `repo-starter-kit.yml`
+- `repo-starter-kit.yaml`
+- `repo-starter-kit.json`
+
+With its content as:
+
+```yaml
+labels: <path to labels file>
+issue: <path to issue file>
+```
+
+For reference, please check https://github.com/daiyam/repo-starter-kit-default.
+
+Donations
+---------
+
+Support this project by becoming a financial contributor.
+
+<table>
+    <tr>
+        <td><img src="https://raw.githubusercontent.com/daiyam/assets/master/icons/256/funding_kofi.png" alt="Ko-fi" width="80px" height="80px"></td>
+        <td><a href="https://ko-fi.com/daiyam" target="_blank">ko-fi.com/daiyam</a></td>
+    </tr>
+    <tr>
+        <td><img src="https://raw.githubusercontent.com/daiyam/assets/master/icons/256/funding_liberapay.png" alt="Liberapay" width="80px" height="80px"></td>
+        <td><a href="https://liberapay.com/daiyam/donate" target="_blank">liberapay.com/daiyam/donate</a></td>
+    </tr>
+    <tr>
+        <td><img src="https://raw.githubusercontent.com/daiyam/assets/master/icons/256/funding_paypal.png" alt="PayPal" width="80px" height="80px"></td>
+        <td><a href="https://paypal.me/daiyam99" target="_blank">paypal.me/daiyam99</a></td>
+    </tr>
+</table>
+
+License
+-------
+
+Copyright &copy; 2025-present Baptiste Augrain
+
+Licensed under the [MIT license](https://opensource.org/licenses/MIT).

package/bin/repo-starter-kit

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../lib/cli.js';

package/lib/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/cli.js

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+import pkg from '../package.json' with { type: 'json' };
+import { run } from './run.js';
+const program = new Command();
+program
+    .version(pkg.version, '-v, --version')
+    .description(pkg.description)
+    .requiredOption('-r, --repo <owner/name>', 'Target repository (OWNER/NAME)')
+    .option('-l, --labels <path>', 'Path to labels YAML')
+    .option('-i, --issue <path>', 'Path to issue Markdown template')
+    .option('-p, --package <name>', 'NPM package that includes a repo-starter-kit config file')
+    .option('-k, --keep-labels', 'Do not delete labels missing from the configuration', false)
+    .action(run);
+program.parse();

package/lib/config/load-package-config.d.ts

@@ -0,0 +1,5 @@
+import { type Result } from '@zokugun/xtry';
+export declare function loadPackageConfig(packageName: string): Promise<Result<{
+    labelsPath?: string;
+    issuePath?: string;
+}, string>>;

package/lib/config/load-package-config.js

@@ -0,0 +1,130 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { err, ok, stringifyError, xtry } from '@zokugun/xtry';
+import pacote from 'pacote';
+import { temporaryDirectory } from 'tempy';
+import YAML from 'yaml';
+import { isNodeError } from '../utils/is-node-error.js';
+import { isRecord } from '../utils/is-record.js';
+const CONFIG_FILES = [
+    {
+        name: 'repo-starter-kit.yml',
+        type: 'yaml',
+    },
+    {
+        name: 'repo-starter-kit.yaml',
+        type: 'yaml',
+    },
+    {
+        name: 'repo-starter-kit.json',
+        type: 'json',
+    },
+    {
+        name: 'repo-starter-kit',
+    },
+];
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+export async function loadPackageConfig(packageName) {
+    const normalizedName = normalizePackageName(packageName);
+    if (normalizedName.fails) {
+        return normalizedName;
+    }
+    const packageRoot = await downloadPackage(normalizedName.value);
+    if (packageRoot.fails) {
+        return packageRoot;
+    }
+    const fileConfig = await readConfigFile(packageRoot.value, packageName);
+    if (fileConfig.fails) {
+        return fileConfig;
+    }
+    const labelsPath = typeof fileConfig.value.labels === 'string' ? path.resolve(packageRoot.value, fileConfig.value.labels) : undefined;
+    const issuePath = typeof fileConfig.value.issue === 'string' ? path.resolve(packageRoot.value, fileConfig.value.issue) : undefined;
+    return ok({ labelsPath, issuePath });
+}
+function normalizePackageName(input) {
+    if (!input) {
+        return err('Package name cannot be empty.');
+    }
+    if (input.startsWith('@')) {
+        const slashIndex = input.indexOf('/');
+        if (slashIndex === -1) {
+            return err(`Scoped package '${input}' must include a name after '/'.`);
+        }
+        const scope = input.slice(0, slashIndex);
+        const name = input.slice(slashIndex + 1);
+        if (name.length === 0) {
+            return err(`Scoped package '${input}' is missing the package name.`);
+        }
+        if (name.startsWith('repo-starter-kit-')) {
+            return ok(`${scope}/${name}`);
+        }
+        return ok(`${scope}/repo-starter-kit-${name}`);
+    }
+    if (input.startsWith('repo-starter-kit-')) {
+        return ok(input);
+    }
+    return ok(`repo-starter-kit-${input}`);
+}
+async function downloadPackage(packageName) {
+    const registry = resolveRegistry();
+    const dir = temporaryDirectory();
+    const result = await pacote.extract(packageName, dir, { registry });
+    if (!result.resolved) {
+        return err(result.from);
+    }
+    return ok(dir);
+}
+function resolveRegistry() {
+    const registry = process.env.npm_config_registry;
+    if (typeof registry === 'string' && registry.trim().length > 0) {
+        return registry;
+    }
+    return DEFAULT_REGISTRY;
+}
+async function readConfigFile(packageRoot, packageName) {
+    for (const { name, type } of CONFIG_FILES) {
+        try {
+            const content = await readFile(path.join(packageRoot, name), 'utf8');
+            let data;
+            if (type === 'json') {
+                const result = xtry(() => JSON.parse(content), stringifyError);
+                if (result.fails) {
+                    return result;
+                }
+                data = result.value;
+            }
+            else if (type === 'yaml') {
+                const result = xtry(() => YAML.parse(content), stringifyError);
+                if (result.fails) {
+                    return result;
+                }
+                data = result.value;
+            }
+            else {
+                let result = xtry(() => JSON.parse(content), stringifyError);
+                if (result.fails) {
+                    result = xtry(() => YAML.parse(content), stringifyError);
+                    if (result.fails) {
+                        return result;
+                    }
+                }
+                data = result.value;
+            }
+            if (!isRecord(data)) {
+                return err(`Config file ${name} must export an object.`);
+            }
+            return ok({
+                labels: typeof data.labels === 'string' ? data.labels : undefined,
+                issue: typeof data.issue === 'string' ? data.issue : undefined,
+            });
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === 'ENOENT') {
+                continue;
+            }
+            return err(`Failed to read ${name} from package: ${stringifyError(error)}`);
+        }
+    }
+    return err(`Package ${packageName} must include one of ${CONFIG_FILES.map(({ name }) => name).join(', ')} at its root.`);
+}

package/lib/issues/create-issue.d.ts

@@ -0,0 +1,4 @@
+import { type Octokit } from '@octokit/rest';
+import { type Failure } from '@zokugun/xtry';
+import { type Issue, type RepoReference } from '../types.js';
+export declare function createIssue(octokit: Octokit, repo: RepoReference, { title, body, labels }: Issue): Promise<Failure<string> | undefined>;

package/lib/issues/create-issue.js

@@ -0,0 +1,21 @@
+import { err, stringifyError } from '@zokugun/xtry';
+import * as logger from '../utils/logger.js';
+export async function createIssue(octokit, repo, { title, body, labels }) {
+    try {
+        const response = await octokit.rest.issues.create({
+            ...repo,
+            title,
+            body,
+            labels,
+        });
+        const issueNumber = response.data.number;
+        await octokit.rest.issues.lock({
+            ...repo,
+            issue_number: issueNumber,
+        });
+        logger.log(`Created issue '${title}'.`);
+    }
+    catch (error) {
+        return err(stringifyError(error));
+    }
+}

package/lib/issues/load-issue.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from '@zokugun/xtry';
+import { type Issue } from '../types.js';
+export declare function loadIssue(filename: string): Promise<Result<Issue, string>>;

package/lib/issues/load-issue.js

@@ -0,0 +1,18 @@
+import { readFile } from 'node:fs/promises';
+import { err, ok, stringifyError } from '@zokugun/xtry';
+import matter from 'gray-matter';
+export async function loadIssue(filename) {
+    let content;
+    try {
+        content = await readFile(filename, 'utf8');
+    }
+    catch (error) {
+        return err(`Failed to read ${filename} from package: ${stringifyError(error)}`);
+    }
+    const parsed = matter(content);
+    const title = typeof parsed.data.title === 'string' ? parsed.data.title.trim() : '';
+    const rawLabels = Array.isArray(parsed.data.labels) ? parsed.data.labels : [];
+    const labels = rawLabels.map((label) => String(label).trim()).filter((label) => label.length > 0);
+    const body = parsed.content;
+    return ok({ title, body, labels });
+}

package/lib/labels/load-labels.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from '@zokugun/xtry';
+import { type Label } from '../types.js';
+export declare function loadLabels(filename: string): Promise<Result<Label[], string>>;

package/lib/labels/load-labels.js

@@ -0,0 +1,30 @@
+import { readFile } from 'node:fs/promises';
+import { err, ok, stringifyError } from '@zokugun/xtry';
+import YAML from 'yaml';
+import { isRecord } from '../utils/is-record.js';
+export async function loadLabels(filename) {
+    let content;
+    try {
+        content = await readFile(filename, 'utf8');
+    }
+    catch (error) {
+        return err(`Failed to read ${filename} from package: ${stringifyError(error)}`);
+    }
+    const records = YAML.parse(content);
+    if (!Array.isArray(records)) {
+        return err(`Label file ${filename} must contain an array.`);
+    }
+    const labels = [];
+    for (const record of records) {
+        if (!isRecord(record)) {
+            continue;
+        }
+        const name = String(record.name ?? '').trim();
+        const color = String(record.color ?? '').trim();
+        const description = String(record.description ?? '').trim();
+        if (name.length > 0) {
+            labels.push({ name, color, description });
+        }
+    }
+    return ok(labels);
+}

package/lib/labels/sync-labels.d.ts

@@ -0,0 +1,4 @@
+import { type Octokit } from '@octokit/rest';
+import { type Failure } from '@zokugun/xtry';
+import { type Label, type RepoReference } from '../types.js';
+export declare function syncLabels(octokit: Octokit, repo: RepoReference, labels: Label[], keepExisting?: boolean): Promise<Failure<string> | undefined>;

package/lib/labels/sync-labels.js

@@ -0,0 +1,71 @@
+import { err, stringifyError, xatry } from '@zokugun/xtry';
+import { isRecord } from '../utils/is-record.js';
+import * as logger from '../utils/logger.js';
+export async function syncLabels(octokit, repo, labels, keepExisting = false) {
+    if (labels.length === 0) {
+        logger.warn('No labels defined; skipping label sync.');
+        return;
+    }
+    const desiredNames = new Set();
+    for (const label of labels) {
+        const color = label.color.replace(/^#/, '').toLowerCase();
+        if (!color) {
+            logger.warn(`Skipping label '${label.name}' because it lacks a color.`);
+            continue;
+        }
+        if (label.description && label.description.length > 100) {
+            logger.warn(`Skipping label '${label.name}' because its description is too long (100 max).`);
+            continue;
+        }
+        desiredNames.add(label.name);
+        try {
+            await octokit.rest.issues.createLabel({
+                ...repo,
+                name: label.name,
+                color,
+                description: label.description,
+            });
+            logger.log(`Created label: ${label.name}`);
+        }
+        catch (error) {
+            if (isRecord(error) && 'status' in error && error.status === 422) {
+                const result = await xatry(octokit.rest.issues.updateLabel({
+                    ...repo,
+                    name: label.name,
+                    new_name: label.name,
+                    color,
+                    description: label.description,
+                }), stringifyError);
+                if (result.fails) {
+                    return result;
+                }
+                logger.log(`Updated label: ${label.name}`);
+            }
+            else {
+                return err(stringifyError(error));
+            }
+        }
+    }
+    if (keepExisting) {
+        logger.log('Keeping existing labels that are not in the configuration.');
+        return;
+    }
+    await deleteMissingLabels(octokit, repo, desiredNames);
+}
+async function deleteMissingLabels(octokit, repo, desiredNames) {
+    const existingLabels = await octokit.paginate(octokit.rest.issues.listLabelsForRepo, {
+        ...repo,
+        per_page: 100,
+    });
+    for (const existing of existingLabels) {
+        if (!desiredNames.has(existing.name)) {
+            try {
+                await octokit.rest.issues.deleteLabel({ ...repo, name: existing.name });
+                logger.log(`Deleted label: ${existing.name}`);
+            }
+            catch (error) {
+                logger.warn(`Failed to delete label '${existing.name}': ${stringifyError(error)}`);
+            }
+        }
+    }
+}

package/lib/repos/check-repo.d.ts

@@ -0,0 +1,4 @@
+import { Failure } from '@zokugun/xtry';
+import { type RepoReference } from '../types.js';
+import { Octokit } from '@octokit/rest';
+export declare function repoExists(octokit: Octokit, repo: RepoReference): Promise<Failure<string> | undefined>;

package/lib/repos/check-repo.js

@@ -0,0 +1,13 @@
+export async function repoExists(octokit, repo) {
+    try {
+        await octokit.repos.get({ owner, repo });
+        return true;
+    }
+    catch (err) {
+        // Octokit surfaces HTTP status on the error object
+        if (err.status === 404)
+            return false;
+        // 403 may indicate rate limit or insufficient permission; rethrow in that case
+        throw err;
+    }
+}

package/lib/repos/exists-repo.d.ts

@@ -0,0 +1,4 @@
+import { type Octokit } from '@octokit/rest';
+import { type Result } from '@zokugun/xtry';
+import { type RepoReference } from '../types.js';
+export declare function existsRepo(octokit: Octokit, { owner, repo }: RepoReference): Promise<Result<boolean, string>>;

package/lib/repos/exists-repo.js

@@ -0,0 +1,14 @@
+import { err, ok, stringifyError } from '@zokugun/xtry';
+import { isRecord } from '../utils/is-record.js';
+export async function existsRepo(octokit, { owner, repo }) {
+    try {
+        await octokit.repos.get({ owner, repo });
+        return ok(true);
+    }
+    catch (error) {
+        if (isRecord(error) && 'status' in error && error.status === 404) {
+            return ok(false);
+        }
+        return err(stringifyError(error));
+    }
+}

package/lib/repos/parse-repo.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from '@zokugun/xtry';
+import { type RepoReference } from '../types.js';
+export declare function parseRepo(input: string): Result<RepoReference, string>;

package/lib/repos/parse-repo.js

@@ -0,0 +1,8 @@
+import { err, ok } from '@zokugun/xtry';
+export function parseRepo(input) {
+    const [owner, repo] = input.split('/');
+    if (!owner || !repo) {
+        return err('Repository must use OWNER/NAME format.');
+    }
+    return ok({ owner, repo });
+}

package/lib/run.d.ts

@@ -0,0 +1,2 @@
+import { type CliOptions } from './types.js';
+export declare function run(options: CliOptions): Promise<void>;

package/lib/run.js

@@ -0,0 +1,100 @@
+import path from 'node:path';
+import { createOAuthDeviceAuth } from '@octokit/auth-oauth-device';
+import { Octokit } from '@octokit/rest';
+import clipboardy from 'clipboardy';
+import enquirer from 'enquirer';
+import open from 'open';
+import { loadPackageConfig } from './config/load-package-config.js';
+import { createIssue } from './issues/create-issue.js';
+import { loadIssue } from './issues/load-issue.js';
+import { loadLabels } from './labels/load-labels.js';
+import { syncLabels } from './labels/sync-labels.js';
+import { existsRepo } from './repos/exists-repo.js';
+import { parseRepo } from './repos/parse-repo.js';
+import * as logger from './utils/logger.js';
+export async function run(options) {
+    const start = Date.now();
+    logger.progress('Configuring');
+    const repo = parseRepo(options.repo);
+    if (repo.fails) {
+        return logger.error(repo.error);
+    }
+    let labelsPath = options.labels ? path.resolve(options.labels) : undefined;
+    let issuePath = options.issue ? path.resolve(options.issue) : undefined;
+    logger.progress('Loading');
+    if (options.package) {
+        const packagePaths = await loadPackageConfig(options.package);
+        if (packagePaths.fails) {
+            return logger.error(packagePaths.error);
+        }
+        labelsPath ??= packagePaths.value.labelsPath;
+        issuePath ??= packagePaths.value.issuePath;
+    }
+    let labels;
+    let issue;
+    if (labelsPath) {
+        const result = await loadLabels(labelsPath);
+        if (result.fails) {
+            return logger.error(result.error);
+        }
+        labels = result.value;
+    }
+    if (issuePath) {
+        const result = await loadIssue(issuePath);
+        if (result.fails) {
+            return logger.error(result.error);
+        }
+        issue = result.value;
+    }
+    if (labels ?? issue) {
+        const octokit = new Octokit({
+            authStrategy: createOAuthDeviceAuth,
+            auth: {
+                clientId: 'Ov23lilx93wDQB9QOLFW',
+                clientType: 'oauth-app',
+                scopes: ['repo'],
+                async onVerification({ verification_uri, user_code }) {
+                    logger.log('Authenticate your account at:');
+                    logger.log(verification_uri);
+                    logger.log('Press ENTER to open in the browser...');
+                    await enquirer.prompt({
+                        type: 'invisible',
+                        name: 'open',
+                        message: '',
+                    });
+                    await open(verification_uri);
+                    await clipboardy.write(user_code);
+                    logger.log(`Paste code: ${user_code} (copied to your clipboard)`);
+                },
+            },
+            userAgent: 'repo-starter-kit',
+        });
+        const exists = await existsRepo(octokit, repo.value);
+        if (exists.fails) {
+            return logger.error(exists.error);
+        }
+        else if (!exists.value) {
+            return logger.error(`The repository ${repo.value.owner}/${repo.value.repo} can't be found!`);
+        }
+        if (labels) {
+            logger.progress('Syncing labels');
+            const result = await syncLabels(octokit, repo.value, labels, options.keepLabels);
+            if (result) {
+                return logger.error(result.error);
+            }
+        }
+        if (issue) {
+            logger.progress('Creating issue');
+            const result = await createIssue(octokit, repo.value, issue);
+            if (result) {
+                return logger.error(result.error);
+            }
+        }
+        logger.log(`Repository bootstrap completed for ${repo.value.owner}/${repo.value.repo}`);
+    }
+    else {
+        logger.log('Nothing to do!');
+    }
+    const duration = Math.ceil((Date.now() - start) / 1000);
+    logger.finish(duration);
+}

package/lib/types.d.ts

@@ -0,0 +1,21 @@
+export type CliOptions = {
+    repo: string;
+    labels?: string;
+    issue?: string;
+    package?: string;
+    keepLabels: boolean;
+};
+export type RepoReference = {
+    owner: string;
+    repo: string;
+};
+export type Label = {
+    name: string;
+    color: string;
+    description?: string;
+};
+export type Issue = {
+    title: string;
+    body: string;
+    labels: string[];
+};

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/lib/utils/is-node-error.d.ts

@@ -0,0 +1 @@
+export declare function isNodeError(error: unknown): error is NodeJS.ErrnoException;

package/lib/utils/is-node-error.js

@@ -0,0 +1,6 @@
+export function isNodeError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    return 'code' in error;
+}

package/lib/utils/is-record.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/lib/utils/is-record.js

@@ -0,0 +1,3 @@
+export function isRecord(value) {
+    return Boolean(value) && !Array.isArray(value) && typeof value === 'object';
+}

package/lib/utils/logger.d.ts

@@ -0,0 +1,6 @@
+export type IndicatorLoading = ReturnType<typeof setInterval>;
+export declare function progress(label: string): void;
+export declare function finish(duration: number): void;
+export declare function error(message: string): void;
+export declare function log(message: string): void;
+export declare function warn(message: string): void;

package/lib/utils/logger.js

@@ -0,0 +1,27 @@
+import c from 'ansi-colors';
+import cliSpinners from 'cli-spinners';
+import logUpdate from 'log-update';
+const { dots } = cliSpinners;
+let $loading;
+export function progress(label) {
+    clearInterval($loading);
+    let index = 0;
+    $loading = setInterval(() => {
+        logUpdate(`${c.cyan(dots.frames[index = ++index % dots.frames.length])} ${label}`);
+    }, cliSpinners.dots.interval);
+}
+export function finish(duration) {
+    clearInterval($loading);
+    logUpdate(`🏁 ${c.bold('Done')} (in ${duration}s).`);
+}
+export function error(message) {
+    clearInterval($loading);
+    logUpdate(`${c.red(c.symbols.cross)} ${c.bold('Error!')}`);
+    console.log(message);
+}
+export function log(message) {
+    logUpdate.persist(`${c.cyan(c.symbols.cross)} ${message}`);
+}
+export function warn(message) {
+    logUpdate.persist(`${c.magenta(c.symbols.warning)} ${message}`);
+}

package/lib/utils/parse-repo.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from '@zokugun/xtry';
+import { type RepoReference } from '../types.js';
+export declare function parseRepo(input: string): Result<RepoReference, string>;

package/lib/utils/parse-repo.js

@@ -0,0 +1,8 @@
+import { err, ok } from '@zokugun/xtry';
+export function parseRepo(input) {
+    const [owner, repo] = input.split('/');
+    if (!owner || !repo) {
+        return err('Repository must use OWNER/NAME format.');
+    }
+    return ok({ owner, repo });
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+	"name": "repo-starter-kit",
+	"description": "CLI to bootstrap and sync repository labels, issues and config.",
+	"version": "0.1.1",
+	"author": {
+		"name": "Baptiste Augrain",
+		"email": "daiyam@zokugun.org"
+	},
+	"license": "MIT",
+	"homepage": "https://github.com/zokugun/repo-starter-kit",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/zokugun/repo-starter-kit.git"
+	},
+	"bugs": {
+		"url": "https://github.com/zokugun/repo-starter-kit/issues"
+	},
+	"type": "module",
+	"bin": {
+		"repo-starter-kit": "bin/repo-starter-kit"
+	},
+	"main": "lib/cli.js",
+	"scripts": {
+		"commit": "cz",
+		"compile": "tsc -p src",
+		"lint": "xo",
+		"prepare": "husky; fixpack || true",
+		"prepublishOnly": "npm run compile",
+		"release": "release-it",
+		"watch:source": "tsc-watch -p src"
+	},
+	"dependencies": {
+		"@octokit/auth-oauth-device": "^8.0.3",
+		"@octokit/rest": "^22.0.1",
+		"@zokugun/xtry": "^0.3.0",
+		"ansi-colors": "^4.1.3",
+		"cli-spinners": "^3.3.0",
+		"clipboardy": "^5.0.2",
+		"commander": "^13.1.0",
+		"enquirer": "^2.4.1",
+		"gray-matter": "^4.0.3",
+		"log-update": "^7.0.2",
+		"open": "^11.0.0",
+		"pacote": "^21.0.4",
+		"tempy": "^3.1.0",
+		"yaml": "^2.8.2"
+	},
+	"devDependencies": {
+		"@commitlint/cli": "^19.7.1",
+		"@commitlint/config-conventional": "^19.7.1",
+		"@types/node": "^20.14.8",
+		"@types/pacote": "^11.1.8",
+		"commitizen": "^4.3.1",
+		"fixpack": "^4.0.0",
+		"husky": "^9.1.7",
+		"lint-staged": "^16.1.4",
+		"release-it": "^18.1.2",
+		"tsc-watch": "^6.3.0",
+		"typescript": "^5.7.3",
+		"xo": "0.60.0"
+	},
+	"keywords": [
+		"automation",
+		"cli",
+		"github",
+		"issues",
+		"labels",
+		"repo",
+		"starter"
+	]
+}