create-absolutejs 0.13.5 → 0.13.7

package/dist/commands/initializeGit.d.ts

@@ -1 +1,9 @@
-export declare const initializeGit: (projectName: string) => Promise<void>;
+import type { GithubLinkOption } from '../types';
+type InitializeGitProps = {
+    projectName: string;
+    githubLink: GithubLinkOption;
+    githubRepoUrl: string | undefined;
+    githubVisibility: 'public' | 'private' | undefined;
+};
+export declare const initializeGit: ({ projectName, githubLink, githubRepoUrl, githubVisibility }: InitializeGitProps) => Promise<void>;
+export {};

package/dist/commands/initializeGit.js

@@ -1,7 +1,45 @@
+import { basename } from 'path';
 import { spinner } from '@clack/prompts';
 import { $ } from 'bun';
-import { green, red } from 'picocolors';
-export const initializeGit = async (projectName) => {
+import { dim, green, red, yellow } from 'picocolors';
+const note = (message) => console.log(`${dim('│')}  ${yellow('▲')}  ${message}`);
+const connectExistingRepo = async (projectName, repoUrl) => {
+    const spin = spinner();
+    spin.start(`Connecting to ${repoUrl}…`);
+    await $ `git remote add origin ${`${repoUrl}.git`}`
+        .cwd(projectName)
+        .quiet()
+        .nothrow();
+    const push = await $ `git push -u origin main`
+        .cwd(projectName)
+        .quiet()
+        .nothrow();
+    if (push.exitCode === 0) {
+        spin.stop(green(`Pushed to ${repoUrl}`));
+        return;
+    }
+    spin.stop(yellow(`Added remote ${repoUrl}, but the push didn't complete`));
+    note('Finish it manually with: git push -u origin main');
+};
+const createGithubRepo = async (projectName, visibility, repoUrl) => {
+    const repoName = basename(projectName);
+    const label = repoUrl ?? repoName;
+    const visibilityFlag = visibility === 'public' ? '--public' : '--private';
+    const spin = spinner();
+    spin.start(`Creating ${visibility} repository ${label} on GitHub…`);
+    const res = await $ `gh repo create ${repoName} ${visibilityFlag} --source=. --remote=origin --push`
+        .cwd(projectName)
+        .quiet()
+        .nothrow();
+    if (res.exitCode === 0) {
+        spin.stop(green(`Created and pushed ${label}`));
+        return;
+    }
+    spin.stop(red('Failed to create the GitHub repository'));
+    note(res.stderr.toString().trim() || 'gh repo create failed');
+    note('Create it manually, then: git remote add origin <url> && git push -u origin main');
+};
+export const initializeGit = async ({ projectName, githubLink, githubRepoUrl, githubVisibility }) => {
     const spin = spinner();
     try {
         spin.start('Initializing git repository…');
@@ -14,4 +52,10 @@ export const initializeGit = async (projectName) => {
         spin.cancel(red('Failed to initialize git'));
         throw err;
     }
+    if (githubLink === 'existing' && githubRepoUrl) {
+        await connectExistingRepo(projectName, githubRepoUrl);
+    }
+    else if (githubLink === 'create' && githubVisibility) {
+        await createGithubRepo(projectName, githubVisibility, githubRepoUrl);
+    }
 };

package/dist/generators/configurations/generatePackageJson.d.ts

@@ -2,6 +2,7 @@ import type { CreateConfiguration } from '../../types';
 type CreatePackageJsonProps = Pick<CreateConfiguration, 'authOption' | 'useTailwind' | 'databaseEngine' | 'databaseHost' | 'plugins' | 'orm' | 'frontendDirectories' | 'codeQualityTool'> & {
     projectName: string;
     latest: boolean;
+    repositoryUrl: string | undefined;
 };
-export declare const createPackageJson: ({ projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool }: CreatePackageJsonProps) => Promise<void>;
+export declare const createPackageJson: ({ projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool, repositoryUrl }: CreatePackageJsonProps) => Promise<void>;
 export {};

package/dist/generators/configurations/generatePackageJson.js

@@ -16,7 +16,7 @@ const dbClientCommands = {
     postgresql: 'psql -h localhost -U user -d database',
     singlestore: 'singlestore -u root -ppassword -D database'
 };
-export const createPackageJson = async ({ projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool }) => {
+export const createPackageJson = async ({ projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool, repositoryUrl }) => {
     const flags = computeFlags(frontendDirectories);
     const isLocal = !databaseHost || databaseHost === 'none';
     /* ── Collect all package names that need versions ─────────── */
@@ -250,7 +250,16 @@ export const createPackageJson = async ({ projectName, authOption, plugins, data
         name: projectName,
         scripts,
         type: 'module',
-        version: '0.0.0'
+        version: '0.0.0',
+        // When the project is linked to a GitHub repo, ship the standard npm
+        // support metadata up front so the package never reads as incomplete.
+        ...(repositoryUrl
+            ? {
+                bugs: { url: `${repositoryUrl}/issues` },
+                homepage: repositoryUrl,
+                repository: { type: 'git', url: `${repositoryUrl}.git` }
+            }
+            : {})
     };
     writeFileSync(join(projectName, 'package.json'), JSON.stringify(packageJson, null, 2));
 };

package/dist/generators/db/generateDatabaseTypes.d.ts

@@ -1,8 +1,9 @@
-import { AuthOption, DatabaseEngine, DatabaseHost } from '../../types';
+import { AuthOption, DatabaseEngine, DatabaseHost, ORM } from '../../types';
 type GenerateTypesProps = {
     databaseEngine: DatabaseEngine;
     databaseHost: DatabaseHost;
     authOption: AuthOption;
+    orm?: ORM;
 };
-export declare const generateDatabaseTypes: ({ databaseEngine, databaseHost, authOption }: GenerateTypesProps) => string;
+export declare const generateDatabaseTypes: ({ databaseEngine, databaseHost, authOption, orm }: GenerateTypesProps) => string;
 export {};

package/dist/generators/db/generateDatabaseTypes.js

@@ -1,5 +1,110 @@
 import { isDrizzleDialect } from '../../typeGuards';
-export const generateDatabaseTypes = ({ databaseEngine, databaseHost, authOption }) => {
+// Driver type used as `DatabaseType` on the raw-SQL (no-ORM) path. Keyed by
+// `${engine}:${host}` where host is 'none' for a locally-hosted engine. These
+// MUST stay in sync with the `dbType` values in handlerTemplates.ts and the
+// `const db = ...` expression in generateDBBlock.ts, otherwise the generated
+// handler's `db` parameter type won't match the value the server constructs.
+const SQL_DRIVER_TYPES = {
+    'cockroachdb:none': {
+        importLine: `import type { SQL } from 'bun';`,
+        typeName: 'SQL'
+    },
+    'gel:none': {
+        importLine: `import type { Client } from 'gel';`,
+        typeName: 'Client'
+    },
+    'mariadb:none': {
+        importLine: `import type { SQL } from 'bun';`,
+        typeName: 'SQL'
+    },
+    'mongodb:none': {
+        importLine: `import type { Db } from 'mongodb';`,
+        typeName: 'Db'
+    },
+    'mssql:none': {
+        importLine: `import type { ConnectionPool } from 'mssql';`,
+        typeName: 'ConnectionPool'
+    },
+    'mysql:none': {
+        importLine: `import type { SQL } from 'bun';`,
+        typeName: 'SQL'
+    },
+    'mysql:planetscale': {
+        importLine: `import type { Client } from '@planetscale/database';`,
+        typeName: 'Client'
+    },
+    'postgresql:neon': {
+        importLine: `import type { Pool } from '@neondatabase/serverless';`,
+        typeName: 'Pool'
+    },
+    'postgresql:none': {
+        importLine: `import type { SQL } from 'bun';`,
+        typeName: 'SQL'
+    },
+    'postgresql:planetscale': {
+        importLine: `import type { Pool } from 'pg';`,
+        typeName: 'Pool'
+    },
+    'singlestore:none': {
+        importLine: `import type { Pool } from 'mysql2/promise';`,
+        typeName: 'Pool'
+    },
+    'sqlite:none': {
+        importLine: `import type { Database } from 'bun:sqlite';`,
+        typeName: 'Database'
+    },
+    'sqlite:turso': {
+        importLine: `import type { Client } from '@libsql/client';`,
+        typeName: 'Client'
+    }
+};
+// Raw-SQL (no-ORM) `databaseTypes.ts`. The drizzle path infers User/NewUser
+// from the schema's `$inferSelect`/`$inferInsert`; without an ORM there is no
+// schema module, so we hand-roll types that mirror the columns emitted by
+// generateSqliteSchema / the relational DDL. Returns rows are untyped at the
+// driver level, so these are the source of truth for consumers (auth config,
+// handlers, the example page).
+const generateSqlDatabaseTypes = ({ databaseEngine, databaseHost, authOption }) => {
+    const host = databaseHost && databaseHost !== 'none' ? databaseHost : 'none';
+    const driver = SQL_DRIVER_TYPES[`${databaseEngine}:${host}`];
+    const driverImport = driver ? `${driver.importLine}\n` : '';
+    const databaseTypeLine = driver
+        ? `export type DatabaseType = ${driver.typeName};`
+        : 'export type DatabaseType = unknown;';
+    const entityTypes = authOption === 'abs'
+        ? `export type User = {
+	auth_sub: string;
+	created_at: Date;
+	metadata: Record<string, unknown>;
+};
+
+export type NewUser = {
+	auth_sub: string;
+	metadata?: Record<string, unknown>;
+};`
+        : `export type CountHistory = {
+	uid: number;
+	count: number;
+	created_at: Date;
+};
+
+export type NewCountHistory = {
+	count: number;
+};`;
+    return `${driverImport}
+${databaseTypeLine}
+
+${entityTypes}
+`;
+};
+export const generateDatabaseTypes = ({ databaseEngine, databaseHost, authOption, orm }) => {
+    if (orm !== 'drizzle') {
+        return generateSqlDatabaseTypes({
+            authOption,
+            databaseEngine,
+            databaseHost
+        });
+    }
     let dbImport = '';
     let dbTypeLine = '';
     if (databaseHost === 'neon') {

package/dist/generators/db/generateRelationalSchema.d.ts

@@ -0,0 +1,3 @@
+import { AuthOption, DatabaseEngine } from '../../types';
+export declare const supportsRelationalSchema: (engine: DatabaseEngine) => boolean;
+export declare const generateRelationalSchema: (databaseEngine: DatabaseEngine, authOption: AuthOption) => string;

package/dist/generators/db/generateRelationalSchema.js

@@ -0,0 +1,52 @@
+const DIALECTS = {
+    cockroachdb: {
+        json: 'JSONB',
+        pk: 'INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY',
+        string: 'VARCHAR(255)',
+        timestamp: 'TIMESTAMP NOT NULL DEFAULT now()'
+    },
+    mariadb: {
+        json: 'JSON',
+        pk: 'INT AUTO_INCREMENT PRIMARY KEY',
+        string: 'VARCHAR(255)',
+        timestamp: 'TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP'
+    },
+    mysql: {
+        json: 'JSON',
+        pk: 'INT AUTO_INCREMENT PRIMARY KEY',
+        string: 'VARCHAR(255)',
+        timestamp: 'TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP'
+    },
+    postgresql: {
+        json: 'JSONB',
+        pk: 'INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY',
+        string: 'VARCHAR(255)',
+        timestamp: 'TIMESTAMP NOT NULL DEFAULT now()'
+    },
+    singlestore: {
+        json: 'JSON',
+        pk: 'INT AUTO_INCREMENT PRIMARY KEY',
+        string: 'VARCHAR(255)',
+        timestamp: 'TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP'
+    }
+};
+export const supportsRelationalSchema = (engine) => engine !== undefined && engine in DIALECTS;
+export const generateRelationalSchema = (databaseEngine, authOption) => {
+    if (databaseEngine === undefined || !(databaseEngine in DIALECTS)) {
+        throw new Error(`Internal error: no relational DDL for engine "${databaseEngine}"`);
+    }
+    const d = DIALECTS[databaseEngine];
+    return authOption === 'abs'
+        ? `CREATE TABLE IF NOT EXISTS users (
+  auth_sub ${d.string} PRIMARY KEY,
+  created_at ${d.timestamp},
+  metadata ${d.json} DEFAULT ('{}')
+);
+`
+        : `CREATE TABLE IF NOT EXISTS count_history (
+  uid ${d.pk},
+  count INT NOT NULL,
+  created_at ${d.timestamp}
+);
+`;
+};

package/dist/generators/db/handlerTemplates.js

@@ -7,6 +7,7 @@ export const getUser = async (db: DatabaseType, authSub: string) => {
 };
 
 export const createUser = async (db: DatabaseType, newUserData: NewUser) => {
+	const { auth_sub: authSub, metadata: userIdentity } = newUserData;
 	${queries.insertUser}
 }`;
 const buildSqlCountTemplate = ({ importLines, dbType, queries }) => `

package/dist/generators/db/scaffoldDatabase.js

@@ -8,6 +8,7 @@ import { createDrizzleConfig } from '../configurations/generateDrizzleConfig';
 import { generateDatabaseTypes } from './generateDatabaseTypes';
 import { generateDrizzleSchema } from './generateDrizzleSchema';
 import { generateDBHandlers } from './generateHandlers';
+import { generateRelationalSchema, supportsRelationalSchema } from './generateRelationalSchema';
 import { generateSqliteSchema } from './generateSqliteSchema';
 import { scaffoldDocker } from './scaffoldDocker';
 export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHost, databaseDirectory, backendDirectory, authOption, orm, typesDirectory }) => {
@@ -26,6 +27,30 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         usesAuth
     });
     writeFileSync(join(handlerDirectory, handlerFileName), dbHandlers, 'utf-8');
+    // Raw-SQL (no-ORM) auth handlers import `DatabaseType`/`NewUser` from
+    // types/databaseTypes (so do the auth config and the example page), but
+    // the drizzle-backed type module below is only written on the drizzle
+    // path. Generate a self-contained, driver-typed version here so the
+    // non-drizzle auth scaffold actually type-checks and builds.
+    if (usesAuth && orm !== 'drizzle') {
+        mkdirSync(typesDirectory, { recursive: true });
+        const sqlTypes = generateDatabaseTypes({
+            authOption,
+            databaseEngine,
+            databaseHost,
+            orm
+        });
+        writeFileSync(join(typesDirectory, 'databaseTypes.ts'), sqlTypes);
+    }
+    // Hosted relational engines on the raw-SQL path get no migration tooling
+    // (no drizzle-kit, no local sqlite3). Emit a plain DDL file so the tables
+    // the handlers query can be created against the hosted database.
+    const isRemoteHost = databaseHost !== undefined && databaseHost !== 'none';
+    if (isRemoteHost &&
+        orm !== 'drizzle' &&
+        supportsRelationalSchema(databaseEngine)) {
+        writeFileSync(join(projectDatabaseDirectory, 'schema.sql'), generateRelationalSchema(databaseEngine, authOption));
+    }
     if (databaseEngine === 'sqlite') {
         void ((orm === undefined || orm === 'none') &&
             (await checkSqliteInstalled()));
@@ -58,7 +83,8 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         const drizzleTypes = generateDatabaseTypes({
             authOption,
             databaseEngine,
-            databaseHost
+            databaseHost,
+            orm
         });
         writeFileSync(join(typesDirectory, 'databaseTypes.ts'), drizzleTypes);
         return { dockerFreshInstall: false };

package/dist/generators/project/generateDBBlock.js

@@ -20,8 +20,11 @@ const connectionMap = {
         planetscale: { expr: 'new Client({ url: getEnv("DATABASE_URL") })' }
     },
     postgresql: {
+        // Raw-SQL (no-ORM) neon uses the driver's `Pool`, whose `.query(text,
+        // params)` → `{ rows }` API matches the generated handler. The drizzle
+        // path is handled separately below and still uses `neon()` http.
         neon: {
-            expr: 'neon(getEnv("DATABASE_URL"));'
+            expr: 'new Pool({ connectionString: getEnv("DATABASE_URL") })'
         },
         none: { expr: 'new SQL(getEnv("DATABASE_URL"))' },
         planetscale: {

package/dist/generators/project/generateImportsBlock.js

@@ -107,7 +107,10 @@ export const generateImportsBlock = ({ deps, flags, orm, authOption, databaseEng
     const getPostgresqlNoOrmImports = () => {
         if (isRemoteHost && databaseHost === 'neon')
             return [
-                ...connectorImports[databaseHost],
+                // No-ORM neon constructs `new Pool(...)` (see generateDBBlock),
+                // whose `.query()` API matches the generated SQL handler. The
+                // `neon()` http client is only used on the drizzle path.
+                `import { Pool } from '@neondatabase/serverless'`,
                 `import { getEnv } from '@absolutejs/absolute'`
             ];
         if (isRemoteHost && databaseHost === 'planetscale')

package/dist/generators/react/generateReactComponents.js

@@ -122,7 +122,7 @@ export const generateReactExamplePage = (authOption) => {
         : `<Dropdown />`;
     const closing = authOption === 'abs' ? `};` : `);`;
     return `
-${authOption === 'abs' ? `import { User } from '../../../types/databaseTypes';\nimport { extractPropFromIdentity, ProviderConfiguration } from '@absolutejs/auth';` : ''}
+${authOption === 'abs' ? `import type { User } from '../../../types/databaseTypes';\nimport { extractPropFromIdentity } from '@absolutejs/auth';\nimport type { ProviderConfiguration } from '@absolutejs/auth';` : ''}
 import { App } from '../components/App';
 import { Dropdown } from '../components/Dropdown';
 import { Head } from '../components/Head';

package/dist/prompt.js

@@ -6,6 +6,7 @@ import { getDatabaseHost } from './questions/databaseHost';
 import { getDirectoryConfiguration } from './questions/directoryConfiguration';
 import { getFrontendDirectoryConfigurations } from './questions/frontendDirectoryConfigurations';
 import { getFrontends } from './questions/frontends';
+import { getGithubLink } from './questions/githubLink';
 import { getHtmlScriptingOption } from './questions/htmlScriptingOption';
 import { getInitializeGit } from './questions/initializeGitNow';
 import { getInstallDependencies } from './questions/installDependenciesNow';
@@ -56,6 +57,25 @@ export const prompt = async (argumentConfiguration) => {
     const plugins = argumentConfiguration.plugins?.filter((plugin) => plugin !== undefined) ?? (await getPlugins());
     // 14. Initialize Git repository
     const initializeGitNow = argumentConfiguration.initializeGitNow ?? (await getInitializeGit());
+    // 14b. Optionally connect the new project to GitHub
+    const resolveGithubLink = async () => {
+        if (!initializeGitNow) {
+            return {
+                githubLink: 'skip',
+                githubRepoUrl: undefined,
+                githubVisibility: undefined
+            };
+        }
+        if (argumentConfiguration.githubLink) {
+            return {
+                githubLink: argumentConfiguration.githubLink,
+                githubRepoUrl: argumentConfiguration.githubRepoUrl,
+                githubVisibility: argumentConfiguration.githubVisibility
+            };
+        }
+        return getGithubLink(projectName);
+    };
+    const { githubLink, githubRepoUrl, githubVisibility } = await resolveGithubLink();
     // 15. Install dependencies
     const installDependenciesNow = argumentConfiguration.installDependenciesNow ??
         (await getInstallDependencies());
@@ -71,6 +91,9 @@ export const prompt = async (argumentConfiguration) => {
         directoryConfig,
         frontendDirectories,
         frontends,
+        githubLink,
+        githubRepoUrl,
+        githubVisibility,
         initializeGitNow,
         installDependenciesNow,
         orm,

package/dist/questions/githubLink.d.ts

@@ -0,0 +1,7 @@
+import type { GithubLinkOption } from '../types';
+export type GithubLinkResult = {
+    githubLink: GithubLinkOption;
+    githubRepoUrl: string | undefined;
+    githubVisibility: 'public' | 'private' | undefined;
+};
+export declare const getGithubLink: (projectName: string) => Promise<GithubLinkResult>;

package/dist/questions/githubLink.js

@@ -0,0 +1,84 @@
+import { basename } from 'path';
+import { isCancel, select, text } from '@clack/prompts';
+import { dim, yellow } from 'picocolors';
+import { abort } from '../utils/abort';
+import { getGhLogin, hasGh, isGhAuthenticated, normalizeRepoInput } from '../utils/github';
+const SKIP = {
+    githubLink: 'skip',
+    githubRepoUrl: undefined,
+    githubVisibility: undefined
+};
+const warn = (message) => console.log(`${dim('│')}\n${yellow('▲')}  ${message}`);
+const linkExistingRepo = async () => {
+    const entered = await text({
+        message: 'Repository (owner/name or full GitHub URL):',
+        placeholder: 'your-org/your-repo',
+        validate: (value) => normalizeRepoInput(value)
+            ? undefined
+            : 'Enter owner/name or a github.com URL'
+    });
+    if (isCancel(entered))
+        abort();
+    const result = {
+        githubLink: 'existing',
+        githubRepoUrl: normalizeRepoInput(entered)?.httpsUrl,
+        githubVisibility: undefined
+    };
+    return result;
+};
+const createNewRepo = async (projectName) => {
+    if (!(await hasGh())) {
+        warn('GitHub CLI (gh) not found — skipping GitHub setup. Install it from https://cli.github.com, then push manually.');
+        return SKIP;
+    }
+    if (!(await isGhAuthenticated())) {
+        warn('GitHub CLI is not authenticated — run `gh auth login`, then re-run. Skipping GitHub setup.');
+        return SKIP;
+    }
+    const login = await getGhLogin();
+    if (!login) {
+        warn("Couldn't resolve your GitHub account — skipping GitHub setup.");
+        return SKIP;
+    }
+    const repoName = basename(projectName);
+    const visibility = await select({
+        message: `Visibility for github.com/${login}/${repoName}:`,
+        options: [
+            { label: 'Private', value: 'private' },
+            { label: 'Public', value: 'public' }
+        ]
+    });
+    if (isCancel(visibility))
+        abort();
+    const result = {
+        githubLink: 'create',
+        githubRepoUrl: `https://github.com/${login}/${repoName}`,
+        githubVisibility: visibility === 'public' ? 'public' : 'private'
+    };
+    return result;
+};
+export const getGithubLink = async (projectName) => {
+    const choice = await select({
+        message: 'Connect this project to GitHub?',
+        options: [
+            {
+                hint: 'set the remote to a repo you already own',
+                label: 'Link an existing repository',
+                value: 'existing'
+            },
+            {
+                hint: 'create one for you with the GitHub CLI',
+                label: 'Create a new repository',
+                value: 'create'
+            },
+            { label: 'Skip', value: 'skip' }
+        ]
+    });
+    if (isCancel(choice))
+        abort();
+    if (choice === 'existing')
+        return linkExistingRepo();
+    if (choice === 'create')
+        return createNewRepo(projectName);
+    return SKIP;
+};

package/dist/scaffold.d.ts

@@ -5,7 +5,7 @@ type ScaffoldProps = {
     latest: boolean;
     envVariables: string[] | undefined;
 };
-export declare const scaffold: ({ response: { projectName, codeQualityTool, initializeGitNow, databaseEngine, databaseHost, useHTMLScripts, useTailwind, databaseDirectory, absProviders, orm, frontends, plugins, authOption, buildDirectory, assetsDirectory, tailwind, installDependenciesNow, frontendDirectories }, latest, envVariables, packageManager }: ScaffoldProps) => Promise<{
+export declare const scaffold: ({ response: { projectName, codeQualityTool, initializeGitNow, githubLink, githubRepoUrl, githubVisibility, databaseEngine, databaseHost, useHTMLScripts, useTailwind, databaseDirectory, absProviders, orm, frontends, plugins, authOption, buildDirectory, assetsDirectory, tailwind, installDependenciesNow, frontendDirectories }, latest, envVariables, packageManager }: ScaffoldProps) => Promise<{
     dockerFreshInstall: boolean;
 }>;
 export {};

package/dist/scaffold.js

@@ -10,7 +10,7 @@ import { scaffoldConfigurationFiles } from './generators/configurations/scaffold
 import { scaffoldDatabase } from './generators/db/scaffoldDatabase';
 import { scaffoldBackend } from './generators/project/scaffoldBackend';
 import { scaffoldFrontends } from './generators/project/scaffoldFrontends';
-export const scaffold = async ({ response: { projectName, codeQualityTool, initializeGitNow, databaseEngine, databaseHost, useHTMLScripts, useTailwind, databaseDirectory, absProviders, orm, frontends, plugins, authOption, buildDirectory, assetsDirectory, tailwind, installDependenciesNow, frontendDirectories }, latest, envVariables, packageManager }) => {
+export const scaffold = async ({ response: { projectName, codeQualityTool, initializeGitNow, githubLink, githubRepoUrl, githubVisibility, databaseEngine, databaseHost, useHTMLScripts, useTailwind, databaseDirectory, absProviders, orm, frontends, plugins, authOption, buildDirectory, assetsDirectory, tailwind, installDependenciesNow, frontendDirectories }, latest, envVariables, packageManager }) => {
     const __dirname = dirname(fileURLToPath(import.meta.url));
     const templatesDirectory = join(__dirname, '/templates');
     const { frontendDirectory, backendDirectory, projectAssetsDirectory, typesDirectory } = initalizeRoot(projectName, templatesDirectory);
@@ -36,6 +36,7 @@ export const scaffold = async ({ response: { projectName, codeQualityTool, initi
         orm,
         plugins,
         projectName,
+        repositoryUrl: githubRepoUrl,
         useTailwind
     });
     scaffoldBackend({
@@ -102,7 +103,12 @@ export const server = treaty<Server>(serverUrl)
         projectName
     });
     if (initializeGitNow) {
-        await initializeGit(projectName);
+        await initializeGit({
+            githubLink,
+            githubRepoUrl,
+            githubVisibility,
+            projectName
+        });
     }
     return { dockerFreshInstall };
 };

package/dist/typeGuards.d.ts

@@ -1,10 +1,11 @@
-import type { AuthOption, AvailableDrizzleDialect, CodeQualityTool, DatabaseEngine, DatabaseHost, Frontend, ORM } from './types';
+import type { AuthOption, AvailableDrizzleDialect, CodeQualityTool, DatabaseEngine, DatabaseHost, Frontend, GithubLinkOption, ORM } from './types';
 export declare const isCodeQualityTool: (value: string | undefined) => value is CodeQualityTool;
 export declare const isDatabaseEngine: (value: string | undefined) => value is DatabaseEngine;
 export declare const isDatabaseHost: (value: string | undefined) => value is DatabaseHost;
 export declare const isDirectoryConfig: (value: string) => value is "default" | "custom";
 export declare const isDrizzleDialect: (value: string | undefined) => value is AvailableDrizzleDialect;
 export declare const isFrontend: (value: string | undefined) => value is Frontend;
+export declare const isGithubLinkOption: (value: string | undefined) => value is GithubLinkOption;
 export declare const isORM: (value: string | undefined) => value is ORM;
 export declare const isPrismaDialect: (value: string | undefined) => value is string;
 export declare const isValidAuthOption: (value: string | undefined) => value is AuthOption;

package/dist/typeGuards.js

@@ -5,6 +5,7 @@ export const isDatabaseHost = (value) => availableDatabaseHosts.some((host) => h
 export const isDirectoryConfig = (value) => value === 'default' || value === 'custom';
 export const isDrizzleDialect = (value) => availableDrizzleDialects.some((dialect) => dialect === value);
 export const isFrontend = (value) => value !== undefined && Object.keys(frontendLabels).includes(value);
+export const isGithubLinkOption = (value) => value === 'existing' || value === 'create' || value === 'skip';
 export const isORM = (value) => value === 'drizzle' || value === 'prisma' || value === undefined;
 export const isPrismaDialect = (value) => availablePrismaDialects.some((dialect) => dialect === value);
 export const isValidAuthOption = (value) => value === 'abs' || value === 'none' || value === undefined;

package/dist/types.d.ts

@@ -40,6 +40,7 @@ export type TailwindConfig = {
     input: string;
     output: string;
 } | undefined;
+export type GithubLinkOption = 'existing' | 'create' | 'skip';
 export type CreateConfiguration = {
     absProviders: ProviderOption[] | undefined;
     assetsDirectory: string;
@@ -51,6 +52,9 @@ export type CreateConfiguration = {
     frontends: Frontend[];
     useHTMLScripts: boolean;
     initializeGitNow: boolean;
+    githubLink: GithubLinkOption;
+    githubRepoUrl: string | undefined;
+    githubVisibility: 'public' | 'private' | undefined;
     installDependenciesNow: boolean;
     codeQualityTool: CodeQualityTool;
     orm: ORM;

package/dist/utils/github.d.ts

@@ -0,0 +1,16 @@
+/** The authenticated GitHub login, or undefined when it can't be resolved. */
+export declare const getGhLogin: () => Promise<string | undefined>;
+/** True when the GitHub CLI (`gh`) is on the PATH. */
+export declare const hasGh: () => Promise<boolean>;
+/** True when `gh` has an authenticated account. */
+export declare const isGhAuthenticated: () => Promise<boolean>;
+/**
+ * Accepts `owner/name`, `https://github.com/owner/name(.git)`, or
+ * `git@github.com:owner/name(.git)` and returns a normalized https URL plus
+ * the parsed owner/name. Returns undefined when the input isn't recognizable.
+ */
+export declare const normalizeRepoInput: (input: string | undefined) => {
+    httpsUrl: string;
+    name: string;
+    owner: string;
+} | undefined;

package/dist/utils/github.js

@@ -0,0 +1,41 @@
+import { platform } from 'process';
+import { $ } from 'bun';
+/** The authenticated GitHub login, or undefined when it can't be resolved. */
+export const getGhLogin = async () => {
+    const res = await $ `gh api user --jq .login`.quiet().nothrow();
+    if (res.exitCode !== 0)
+        return undefined;
+    return res.stdout.toString().trim() || undefined;
+};
+/** True when the GitHub CLI (`gh`) is on the PATH. */
+export const hasGh = async () => (platform === 'win32'
+    ? await $ `where gh`.quiet().nothrow()
+    : await $ `command -v gh`.quiet().nothrow()).exitCode === 0;
+/** True when `gh` has an authenticated account. */
+export const isGhAuthenticated = async () => (await $ `gh auth status`.quiet().nothrow()).exitCode === 0;
+/**
+ * Accepts `owner/name`, `https://github.com/owner/name(.git)`, or
+ * `git@github.com:owner/name(.git)` and returns a normalized https URL plus
+ * the parsed owner/name. Returns undefined when the input isn't recognizable.
+ */
+export const normalizeRepoInput = (input) => {
+    const trimmed = (input ?? '').trim().replace(/\.git$/, '');
+    const patterns = [
+        /^https?:\/\/github\.com\/([^/\s]+)\/([^/\s]+)$/i,
+        /^git@github\.com:([^/\s]+)\/([^/\s]+)$/i,
+        /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/
+    ];
+    for (const pattern of patterns) {
+        const match = trimmed.match(pattern);
+        const owner = match?.[1];
+        const name = match?.[2];
+        if (owner && name) {
+            return {
+                httpsUrl: `https://github.com/${owner}/${name}`,
+                name,
+                owner
+            };
+        }
+    }
+    return undefined;
+};

package/dist/utils/parseCommandLineOptions.js

@@ -3,7 +3,8 @@ import { parseArgs } from 'util';
 import { isValidProviderOption, providers } from '@absolutejs/auth';
 import { DEFAULT_ARG_LENGTH } from '../constants';
 import { availableAuthProviders, availableDatabaseEngines, availableDatabaseHosts, availableDirectoryConfigurations, availableDrizzleDialects, availableORMs, availablePrismaDialects } from '../data';
-import { isValidAuthOption, isDatabaseEngine, isDatabaseHost, isDirectoryConfig, isDrizzleDialect, isORM, isPrismaDialect } from '../typeGuards';
+import { isValidAuthOption, isDatabaseEngine, isDatabaseHost, isDirectoryConfig, isDrizzleDialect, isGithubLinkOption, isORM, isPrismaDialect } from '../typeGuards';
+import { normalizeRepoInput } from './github';
 export const parseCommandLineOptions = () => {
     const { values, positionals } = parseArgs({
         allowNegative: true,
@@ -25,6 +26,7 @@ export const parseCommandLineOptions = () => {
             env: { multiple: true, type: 'string' },
             'eslint+prettier': { type: 'boolean' },
             git: { type: 'boolean' },
+            github: { type: 'string' },
             help: { default: false, short: 'h', type: 'boolean' },
             html: { type: 'boolean' },
             'html-dir': { type: 'string' },
@@ -37,6 +39,8 @@ export const parseCommandLineOptions = () => {
             plugin: { multiple: true, type: 'string' },
             react: { type: 'boolean' },
             'react-dir': { type: 'string' },
+            repo: { type: 'string' },
+            'repo-visibility': { type: 'string' },
             skip: { type: 'boolean' },
             svelte: { type: 'boolean' },
             'svelte-dir': { type: 'string' },
@@ -232,6 +236,10 @@ export const parseCommandLineOptions = () => {
         validEnv.push(entry);
     }
     values.env = validEnv.length ? validEnv : undefined;
+    const repoVisibility = values['repo-visibility'];
+    const githubVisibility = repoVisibility === 'public' || repoVisibility === 'private'
+        ? repoVisibility
+        : undefined;
     const argumentConfiguration = {
         absProviders: absProviders.length ? absProviders : undefined,
         assetsDirectory: values.assets,
@@ -244,6 +252,11 @@ export const parseCommandLineOptions = () => {
         directoryConfig,
         frontendDirectories,
         frontends: selectedFrontends.length ? selectedFrontends : undefined,
+        githubLink: isGithubLinkOption(values.github)
+            ? values.github
+            : undefined,
+        githubRepoUrl: normalizeRepoInput(values.repo)?.httpsUrl,
+        githubVisibility,
         initializeGitNow: values.git,
         installDependenciesNow: values.install,
         orm,

package/dist/versions.d.ts

@@ -4,7 +4,7 @@
  * Run `bun run check-versions` to compare against latest npm versions.
  */
 export declare const versions: {
-    readonly '@absolutejs/absolute': "0.19.0-beta.1069";
+    readonly '@absolutejs/absolute': "0.19.0-beta.1081";
     readonly '@absolutejs/auth': "0.22.7";
     readonly '@angular/common': "21.2.0";
     readonly '@angular/compiler': "21.2.0";

package/dist/versions.js

@@ -5,7 +5,7 @@
  */
 export const versions = {
     /* ── Core ─────────────────────────────────────────────── */
-    '@absolutejs/absolute': '0.19.0-beta.1069',
+    '@absolutejs/absolute': '0.19.0-beta.1081',
     '@absolutejs/auth': '0.22.7',
     /* ── Angular ─────────────────────────────────────────── */
     '@angular/common': '21.2.0',

package/package.json

@@ -10,7 +10,7 @@
 	},
 	"description": "A CLI tool to create a new AbsoluteJS project",
 	"devDependencies": {
-		"@absolutejs/absolute": "0.19.0-beta.1069",
+		"@absolutejs/absolute": "0.19.0-beta.1081",
 		"@eslint/compat": "2.0.2",
 		"@stylistic/eslint-plugin": "5.9.0",
 		"@types/bun": "1.3.8",
@@ -52,5 +52,5 @@
 		"typecheck": "bun run tsc --noEmit"
 	},
 	"type": "module",
-	"version": "0.13.5"
+	"version": "0.13.7"
 }