@funish/basis 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { B as BasisConfig, I as InitOptions, G as GitHooksConfig, C as CommitMessage, L as LintConfig, P as PublishOptions, a as PublishResult, V as VersionOptions, b as VersionUpdateResult } from './shared/basis.iRZ1Ylu8.js';
-export { g as PackageManagerConfig, i as PublishConfig, e as VALID_GIT_HOOKS, f as ValidGitHook, h as VersionConfig, c as defaultConfig, d as defineBasisConfig } from './shared/basis.iRZ1Ylu8.js';
+import { B as BasisConfig, I as InitOptions, V as VersionOptions, a as VersionUpdateResult, P as PublishOptions, b as PublishResult, C as CommitMessage, G as GitConfig, c as GitConfigData, L as LintConfig } from './shared/basis.BvLeB_5F.js';
+export { f as CommitMsgConfig, j as GitConfigSection, i as GitConfigValue, k as PackageManagerConfig, m as PublishConfig, g as VALID_GIT_HOOKS, h as ValidGitHook, l as VersionConfig, e as defaultConfig, d as defineBasisConfig } from './shared/basis.BvLeB_5F.js';
 import * as c12 from 'c12';
 import { LoadConfigOptions } from 'c12';
 
@@ -20,59 +20,211 @@ declare class Basis {
      */
     lintStaged(): Promise<boolean>;
     /**
-     * Run commit message linting
+     * Run linting for entire project
+     */
+    lintProject(): Promise<boolean>;
+    /**
+     * Check project dependencies
+     */
+    lintDependencies(): Promise<boolean>;
+    /**
+     * Check project structure
+     */
+    lintStructure(): Promise<boolean>;
+    /**
+     * Check project documentation
+     */
+    lintDocs(): Promise<boolean>;
+    /**
+     * Run all lint checks
+     */
+    lintAll(): Promise<boolean>;
+    /**
+     * Validate commit message
      */
     lintCommitMessage(): Promise<boolean>;
     /**
-     * Install git hooks
+     * Setup Git hooks
+     */
+    setupGitHooks(): Promise<boolean>;
+    /**
+     * Setup Git configuration
+     */
+    setupGitConfig(): Promise<boolean>;
+    /**
+     * Setup complete Git configuration (hooks + config)
+     */
+    setupGit(): Promise<boolean>;
+    /**
+     * Initialize Git repository with basis configuration
+     */
+    initGitRepo(): Promise<boolean>;
+    /**
+     * Remove Git hooks
+     */
+    removeGitHooks(updateConfig?: boolean): Promise<boolean>;
+    /**
+     * Reset Git configuration
+     */
+    resetGitConfig(keepUser?: boolean, updateConfig?: boolean): Promise<boolean>;
+    /**
+     * Update package version
+     */
+    updateVersion(options?: VersionOptions): Promise<VersionUpdateResult>;
+    /**
+     * Update to specific version
+     */
+    setVersion(version: string): Promise<VersionUpdateResult>;
+    /**
+     * Increment patch version
+     */
+    patchVersion(): Promise<VersionUpdateResult>;
+    /**
+     * Increment minor version
+     */
+    minorVersion(): Promise<VersionUpdateResult>;
+    /**
+     * Increment major version
+     */
+    majorVersion(): Promise<VersionUpdateResult>;
+    /**
+     * Create prerelease version
+     */
+    prereleaseVersion(preid?: string): Promise<VersionUpdateResult>;
+    /**
+     * Publish package to registry
+     */
+    publish(options?: PublishOptions): Promise<PublishResult>;
+    /**
+     * Publish with dry run
+     */
+    publishDryRun(options?: PublishOptions): Promise<PublishResult>;
+    /**
+     * Publish to specific tag
+     */
+    publishToTag(tag: string, options?: PublishOptions): Promise<PublishResult>;
+    /**
+     * Publish as stable release (latest tag)
+     */
+    publishStable(options?: PublishOptions): Promise<PublishResult>;
+    /**
+     * Get current working directory
+     */
+    getCwd(): string;
+    /**
+     * Set working directory
+     */
+    setCwd(cwd: string): void;
+    /**
+     * Reload configuration from file
      */
-    installHooks(): Promise<void>;
+    reloadConfig(): Promise<BasisConfig>;
     /**
-     * Uninstall git hooks
+     * Run complete project setup (init + git setup)
      */
-    uninstallHooks(): Promise<void>;
+    setup(options?: InitOptions): Promise<boolean>;
     /**
-     * List configured git hooks
+     * Run complete release workflow (lint + version + publish)
      */
-    listHooks(): Promise<void>;
+    release(versionOptions?: VersionOptions, publishOptions?: PublishOptions): Promise<{
+        version: VersionUpdateResult;
+        publish: PublishResult;
+    }>;
 }
 /**
  * Create a new Basis instance
  */
 declare function createBasis(cwd?: string): Basis;
 
-declare function installHooks(cwd?: string, config?: GitHooksConfig): Promise<void>;
-declare function uninstallHooks(cwd?: string, config?: GitHooksConfig): Promise<void>;
-declare function listHooks(cwd?: string, config?: GitHooksConfig): Promise<void>;
-
-/**
- * Initialize basis configuration in the current project
- */
-declare function init(cwd?: string, options?: InitOptions): Promise<boolean>;
-
 /**
- * Parse commit message
+ * Parse commit message into structured format
  */
 declare function parseCommitMessage(message: string): CommitMessage | null;
 /**
- * Validate commit message
+ * Validate commit message against rules
  */
-declare function validateCommitMessage(message: string, config?: LintConfig["commitMsg"]): {
+declare function validateCommitMessage(message: string, config?: GitConfig["commitMsg"]): {
     valid: boolean;
     errors: string[];
 };
 /**
- * Get staged files
+ * Lint commit message from Git
+ */
+declare function lintCommitMessage(cwd?: string, config?: GitConfig["commitMsg"]): Promise<boolean>;
+/**
+ * Read Git configuration from .git/config using ini parser
+ */
+declare function readGitConfig(cwd?: string): Promise<GitConfigData>;
+/**
+ * Write Git configuration to .git/config using ini format
+ */
+declare function writeGitConfig(config: GitConfigData, cwd?: string): Promise<void>;
+/**
+ * Setup Git configuration with backup and safe merging
+ */
+declare function setupGitConfig(cwd?: string, config?: GitConfig["config"]): Promise<boolean>;
+/**
+ * Reset Git configuration with backup
+ */
+declare function resetGitConfig(cwd?: string, keepUser?: boolean, options?: {
+    updateConfig?: boolean;
+}): Promise<boolean>;
+/**
+ * Setup Git hooks
+ */
+declare function setupGitHooks(cwd?: string, config?: GitConfig["hooks"]): Promise<boolean>;
+/**
+ * Initialize Git repository with basis configuration
+ */
+declare function initGitRepo(cwd?: string): Promise<boolean>;
+/**
+ * Run comprehensive Git setup
+ */
+declare function setupGit(cwd?: string): Promise<boolean>;
+/**
+ * Remove Git hooks
+ */
+declare function removeGitHooks(cwd?: string, hooksToRemove?: string[], options?: {
+    updateConfig?: boolean;
+}): Promise<boolean>;
+
+/**
+ * Initialize basis configuration in the current project
+ */
+declare function init(cwd?: string, options?: InitOptions): Promise<boolean>;
+
+/**
+ * Get staged files (only existing files, not deleted ones)
  */
 declare function getStagedFiles(): string[];
+/**
+ * Get all project files based on patterns using fast-glob
+ */
+declare function getProjectFiles(cwd: string, patterns?: string[], exclude?: string[]): Promise<string[]>;
 /**
  * Lint staged files
  */
 declare function lintStaged(cwd?: string, config?: LintConfig["staged"]): Promise<boolean>;
 /**
- * Lint commit message
+ * Lint entire project using commands (similar to staged but for all project files)
+ */
+declare function lintProject(cwd?: string, config?: LintConfig["project"]): Promise<boolean>;
+/**
+ * Check dependencies
  */
-declare function lintCommitMessage(cwd?: string, config?: LintConfig["commitMsg"]): Promise<boolean>;
+declare function lintDependencies(cwd?: string, config?: LintConfig["dependencies"]): Promise<boolean>;
+/**
+ * Check project structure
+ */
+declare function lintStructure(cwd?: string, config?: LintConfig["structure"]): Promise<boolean>;
+/**
+ * Check documentation
+ */
+declare function lintDocs(cwd?: string, config?: LintConfig["docs"]): Promise<boolean>;
+/**
+ * Run all lint checks
+ */
+declare function lintAll(cwd?: string): Promise<boolean>;
 
 /**
  * Publish package to npm registry
@@ -85,5 +237,16 @@ declare function publishPackage(cwd: string, options?: PublishOptions): Promise<
 declare function updatePackageVersion(cwd: string, options?: VersionOptions): Promise<VersionUpdateResult>;
 
 declare function loadConfig(options?: LoadConfigOptions<BasisConfig>): Promise<c12.ResolvedConfig<BasisConfig, c12.ConfigLayerMeta>>;
+/**
+ * Check if file or directory exists
+ */
+declare function fileExists(path: string): Promise<boolean>;
+/**
+ * Get package manager specific commands
+ */
+declare function getPackageManagerCommands(packageManager: string): {
+    outdated: string;
+    audit: string;
+};
 
-export { Basis, BasisConfig, CommitMessage, GitHooksConfig, InitOptions, LintConfig, PublishOptions, PublishResult, VersionOptions, VersionUpdateResult, createBasis, getStagedFiles, init, installHooks, lintCommitMessage, lintStaged, listHooks, loadConfig, parseCommitMessage, publishPackage, uninstallHooks, updatePackageVersion, validateCommitMessage };
+export { Basis, BasisConfig, CommitMessage, GitConfig, GitConfigData, InitOptions, LintConfig, PublishOptions, PublishResult, VersionOptions, VersionUpdateResult, createBasis, fileExists, getPackageManagerCommands, getProjectFiles, getStagedFiles, init, initGitRepo, lintAll, lintCommitMessage, lintDependencies, lintDocs, lintProject, lintStaged, lintStructure, loadConfig, parseCommitMessage, publishPackage, readGitConfig, removeGitHooks, resetGitConfig, setupGit, setupGitConfig, setupGitHooks, updatePackageVersion, validateCommitMessage, writeGitConfig };

package/dist/index.mjs

@@ -1 +1 @@
-export{defaultConfig,defineBasisConfig}from"./config.mjs";import{i as s,u as o,l as a}from"./shared/basis.O4so-uuj.mjs";export{V as VALID_GIT_HOOKS}from"./shared/basis.O4so-uuj.mjs";import{i as n}from"./shared/basis.CBZIV3-V.mjs";import{l as r,a as e}from"./shared/basis.rDVxD7qf.mjs";export{g as getStagedFiles,p as parseCommitMessage,v as validateCommitMessage}from"./shared/basis.rDVxD7qf.mjs";import{l as c}from"./shared/basis.C0E7mwQ6.mjs";export{p as publishPackage}from"./shared/basis.dc3ybBoz.mjs";export{u as updatePackageVersion}from"./shared/basis.C5wlo6IO.mjs";import"node:child_process";import"node:fs/promises";import"consola";import"pathe";import"node:fs";import"nypm";import"pkg-types";import"micromatch";import"c12";import"semver";class g{config=null;cwd;constructor(t=process.cwd()){this.cwd=t}async getConfig(){if(!this.config){const{config:t}=await c({cwd:this.cwd});this.config=t}return this.config}async init(t={}){return await n(this.cwd,t)}async lintStaged(){const t=await this.getConfig();return await r(this.cwd,t.lint?.staged)}async lintCommitMessage(){const t=await this.getConfig();return await e(this.cwd,t.lint?.commitMsg)}async installHooks(){const t=await this.getConfig();await s(this.cwd,t.githooks)}async uninstallHooks(){const t=await this.getConfig();await o(this.cwd,t.githooks)}async listHooks(){const t=await this.getConfig();await a(this.cwd,t.githooks)}}function m(i=process.cwd()){return new g(i)}export{g as Basis,m as createBasis,n as init,s as installHooks,e as lintCommitMessage,r as lintStaged,a as listHooks,c as loadConfig,o as uninstallHooks};
+export{defaultConfig,defineBasisConfig}from"./config.mjs";import{l as r,s as n,a as o,b as c,i as p,r as u,c as w}from"./shared/basis.DzMHJtq5.mjs";export{p as parseCommitMessage,d as readGitConfig,v as validateCommitMessage,w as writeGitConfig}from"./shared/basis.DzMHJtq5.mjs";import{i as g}from"./shared/basis.1ZgFrMJb.mjs";import{l as h,a as l,b as m,c as d,d as f,e as y}from"./shared/basis.DcC8NBqt.mjs";export{f as getProjectFiles,g as getStagedFiles}from"./shared/basis.DcC8NBqt.mjs";import{p as e}from"./shared/basis.plLH3j3N.mjs";import{u as i}from"./shared/basis.0WCUjjhy.mjs";import{l as C}from"./shared/basis.CkZpidFZ.mjs";export{f as fileExists,g as getPackageManagerCommands}from"./shared/basis.CkZpidFZ.mjs";import"node:child_process";import"node:fs/promises";import"c12/update";import"consola";import"defu";import"ini";import"pathe";import"magicast";import"nypm";import"pkg-types";import"fast-glob";import"micromatch";import"semver";import"c12";class G{config=null;cwd;constructor(t=process.cwd()){this.cwd=t}async getConfig(){if(!this.config){const{config:t}=await C({cwd:this.cwd});this.config=t}return this.config}async init(t={}){return await g(this.cwd,t)}async lintStaged(){const t=await this.getConfig();return await h(this.cwd,t.lint?.staged)}async lintProject(){const t=await this.getConfig();return await l(this.cwd,t.lint?.project)}async lintDependencies(){const t=await this.getConfig();return await m(this.cwd,t.lint?.dependencies)}async lintStructure(){const t=await this.getConfig();return await d(this.cwd,t.lint?.structure)}async lintDocs(){const t=await this.getConfig();return await f(this.cwd,t.lint?.docs)}async lintAll(){return await y(this.cwd)}async lintCommitMessage(){const t=await this.getConfig();return await r(this.cwd,t.git?.commitMsg)}async setupGitHooks(){const t=await this.getConfig();return await n(this.cwd,t.git?.hooks)}async setupGitConfig(){const t=await this.getConfig();return await o(this.cwd,t.git?.config)}async setupGit(){return await c(this.cwd)}async initGitRepo(){return await p(this.cwd)}async removeGitHooks(t=!1){return await u(this.cwd,void 0,{updateConfig:t})}async resetGitConfig(t=!0,s=!1){return await w(this.cwd,t,{updateConfig:s})}async updateVersion(t={}){return await i(this.cwd,t)}async setVersion(t){return await i(this.cwd,{version:t})}async patchVersion(){return await i(this.cwd,{})}async minorVersion(){return await i(this.cwd,{minor:!0})}async majorVersion(){return await i(this.cwd,{major:!0})}async prereleaseVersion(t){return await i(this.cwd,{prerelease:!0,preid:t})}async publish(t={}){return await e(this.cwd,t)}async publishDryRun(t={}){return await e(this.cwd,{...t,dryRun:!0})}async publishToTag(t,s={}){return await e(this.cwd,{...s,tag:t})}async publishStable(t={}){return await e(this.cwd,{...t,stable:!0})}getCwd(){return this.cwd}setCwd(t){this.cwd=t,this.config=null}async reloadConfig(){return this.config=null,await this.getConfig()}async setup(t={}){return await this.init(t)?await this.setupGit():!1}async release(t={},s={}){if(!await this.lintAll())throw new Error("Lint checks failed. Fix issues before releasing.");const b=await this.updateVersion(t),k=await this.publish(s);return{version:b,publish:k}}}function v(a=process.cwd()){return new G(a)}const V=["applypatch-msg","pre-applypatch","post-applypatch","pre-commit","pre-merge-commit","prepare-commit-msg","commit-msg","post-commit","pre-rebase","post-checkout","post-merge","pre-push","pre-receive","update","proc-receive","post-receive","post-update","reference-transaction","push-to-checkout","pre-auto-gc","post-rewrite","sendemail-validate","fsmonitor-watchman","p4-changelist","p4-prepare-changelist","p4-post-changelist","p4-pre-submit","post-index-change"];export{G as Basis,V as VALID_GIT_HOOKS,v as createBasis,g as init,p as initGitRepo,y as lintAll,r as lintCommitMessage,m as lintDependencies,f as lintDocs,l as lintProject,h as lintStaged,d as lintStructure,C as loadConfig,e as publishPackage,u as removeGitHooks,w as resetGitConfig,c as setupGit,o as setupGitConfig,n as setupGitHooks,i as updatePackageVersion};

package/dist/shared/basis.0WCUjjhy.mjs

@@ -0,0 +1 @@
+import{execSync as g}from"node:child_process";import{consola as s}from"consola";import{readPackageJSON as v,resolvePackageJSON as f,writePackageJSON as h}from"pkg-types";import m from"semver";import{l as $}from"./basis.CkZpidFZ.mjs";async function P(r,o={}){const{config:u}=await $({cwd:r}),i=u.version||{},d=await v(r),t=d.version;if(!t)throw new Error("No version found in package.json");const n=o.version?m.valid(o.version)?o.version:(()=>{throw new Error(`Invalid version format: ${o.version}`)})():(()=>{if(!m.valid(t))throw new Error(`Invalid current version format: ${t}`);const e=m.prerelease(t),c=o.preid||(e&&typeof e[0]=="string"?e[0]:null)||i.prereleaseId||"edge";let a;o.major?a="major":o.minor?a="minor":o.prerelease?a=e?"prerelease":"prepatch":a=e?"prerelease":"patch";const l=a==="prerelease"||a.startsWith("pre")?m.inc(t,a,c):m.inc(t,a);if(!l)throw new Error("Failed to calculate new version");return l})();s.info(`Updating version: ${t} \u2192 ${n}`);const w=await f(r);await h(w,{...d,version:n});const p={oldVersion:t,newVersion:n};if(i.autoCommit){const e=o.message||i.commitMessage?.replace("{version}",n)||`chore: release v${n}`;try{g("git add package.json",{cwd:r}),g(`git commit -m "${e}"`,{cwd:r}),s.success(`Committed version update: ${e}`)}catch(c){s.warn("Failed to commit changes:",c)}}if(i.autoTag){const e=`${i.tagPrefix||"v"}${n}`;try{g(`git tag ${e}`,{cwd:r}),s.success(`Created git tag: ${e}`),p.tagName=e}catch(c){s.warn("Failed to create git tag:",c)}}if(i.autoPush)try{g("git push",{cwd:r}),i.autoTag&&g("git push --tags",{cwd:r}),s.success("Pushed changes to remote")}catch(e){s.warn("Failed to push changes:",e)}return p}export{P as u};

package/dist/shared/basis.1ZgFrMJb.mjs

@@ -0,0 +1,7 @@
+import{updateConfig as k}from"c12/update";import{consola as s}from"consola";import{parseModule as C,builders as b,generateCode as j}from"magicast";import{detectPackageManager as x,addDevDependency as v,installDependencies as D}from"nypm";import{resolve as c}from"pathe";import{readPackageJSON as w,writePackageJSON as B}from"pkg-types";import{f as l}from"./basis.CkZpidFZ.mjs";import{b as S}from"./basis.DzMHJtq5.mjs";const n={ts:{ext:"ts",label:"TypeScript"},mjs:{ext:"mjs",label:"ES Module"},cjs:{ext:"cjs",label:"CommonJS"}};function G(i){const t=C("");if(i==="cjs"){t.imports.$prepend({from:"@funish/basis",imported:"defineBasisConfig",local:"defineBasisConfig"}),t.exports.default=b.functionCall("defineBasisConfig",{});const o=t.exports.default.$args[0];o.$ast.leadingComments=[{type:"Block",value:`
+  Configure your project here
+  See: https://github.com/funish/basis/tree/main/packages/basis#configuration
+  `}]}else{t.imports.$prepend({from:"@funish/basis",imported:"defineBasisConfig",local:"defineBasisConfig"}),t.exports.default=b.functionCall("defineBasisConfig",{});const o=t.exports.default.$args[0];o.$ast.leadingComments=[{type:"Block",value:`
+  Configure your project here
+  See: https://github.com/funish/basis/tree/main/packages/basis#configuration
+  `}]}return j(t).code}async function z(i){if(await l(c(i,"tsconfig.json")))return"ts";try{if((await w(i)).type==="module")return"mjs"}catch{}return"ts"}async function E(i=process.cwd(),t={}){const{force:o=!1,skipGitCheck:$=!1,skipInstall:f=!1}=t;s.start("Initializing basis configuration...");const p=await z(i),m=await s.prompt("Choose config file format:",{type:"select",initial:p,options:[{value:"ts",label:`${n.ts.label} (${n.ts.ext}) ${p==="ts"?"(recommended)":""}`},{value:"mjs",label:`${n.mjs.label} (${n.mjs.ext}) ${p==="mjs"?"(recommended)":""}`},{value:"cjs",label:`${n.cjs.label} (${n.cjs.ext}) ${p==="cjs"?"(recommended)":""}`}]}),g=n[m].ext,r=`basis.config.${g}`,y=c(i,r);if(await l(y)&&!o)return s.error(`${r} already exists. Use --force to overwrite.`),!1;let d=!1;if(!$){if(await l(c(i,".git")))d=await s.prompt("Setup Git hooks and configuration?",{type:"confirm",initial:!0});else if(s.warn("No .git directory found. Git hooks will not work properly."),!await s.prompt("Continue anyway?",{type:"confirm",initial:!1}))return s.info("Initialization cancelled."),!1}const u=(await x(i))?.name||"npm";s.info(`Detected package manager: ${u}`),await k({cwd:i,configFile:"basis.config",createExtension:g,onCreate:()=>(s.info(`Creating ${r}...`),G(m))}),s.success(`Created ${r}`);try{const e=await w(i),h=!!(e.workspaces||await l(c(i,"pnpm-workspace.yaml")));f?!e.devDependencies?.["@funish/basis"]&&!e.dependencies?.["@funish/basis"]&&(e.devDependencies=e.devDependencies||{},e.devDependencies["@funish/basis"]="latest",s.info("Added @funish/basis to devDependencies")):(await v("@funish/basis",{cwd:i,silent:!1,workspace:h}),s.success("Added @funish/basis to devDependencies"));const a="basis git --setup";e.scripts=e.scripts||{},u==="pnpm"?e.scripts.postinstall?e.scripts.postinstall.includes(a)||(e.scripts.postinstall=`${e.scripts.postinstall} && ${a}`):e.scripts.postinstall=a:u==="yarn"?e.scripts.prepare?e.scripts.prepare.includes(a)||(e.scripts.prepare=`${e.scripts.prepare} && ${a}`):e.scripts.prepare=a:e.scripts.postinstall?e.scripts.postinstall.includes(a)||(e.scripts.postinstall=`${e.scripts.postinstall} && ${a}`):e.scripts.postinstall=a,await B(c(i,"package.json"),e),s.success(`Updated package.json scripts${f?" and dependencies":""}`),f?(s.info("Skipped dependency installation"),s.info("Run your package manager's install command to complete setup")):(s.start("Installing dependencies..."),await D({cwd:i,silent:!1}),s.success("Dependencies installed successfully"))}catch(e){return s.error("Failed to setup dependencies:",e),!1}return d&&(s.start("Setting up Git hooks and configuration..."),await S(i)?s.success("Git setup completed!"):s.warn("Git setup failed, but basis config was created successfully")),s.success("Basis initialization completed!"),s.info("You can now:"),s.info(`  - Edit ${r} to customize your configuration`),d||s.info("  - Run `basis git --setup` to install git hooks"),!0}export{E as i};

package/dist/shared/basis.B4p52ive.cjs

@@ -0,0 +1 @@
+"use strict";const node_child_process=require("node:child_process"),consola=require("consola"),nypm=require("nypm"),pkgTypes=require("pkg-types"),g=require("semver"),utils=require("./basis.BJhSbOyA.cjs");function _interopDefaultCompat(a){return a&&typeof a=="object"&&"default"in a?a.default:a}const g__default=_interopDefaultCompat(g);async function k(a,e,o){if(e.checkGitClean&&!o.skipTests)try{if(node_child_process.execSync("git status --porcelain",{cwd:a,encoding:"utf8"}).trim())throw new Error("Working directory is not clean. Commit your changes first.")}catch(s){consola.consola.warn("Could not check git status:",s)}if(e.checkTests&&!o.skipTests){consola.consola.start("Running tests...");try{e.testCommand?node_child_process.execSync(e.testCommand,{cwd:a,stdio:"inherit"}):await nypm.runScript("test",{cwd:a,silent:!1}),consola.consola.success("Tests passed")}catch(s){throw consola.consola.error("Tests failed"),s}}if(e.buildCommand&&!o.skipBuild){consola.consola.start("Building package...");try{e.buildCommand.includes(" ")?node_child_process.execSync(e.buildCommand,{cwd:a,stdio:"inherit"}):await nypm.runScript(e.buildCommand,{cwd:a,silent:!1}),consola.consola.success("Build completed")}catch(s){throw consola.consola.error("Build failed"),s}}}async function C(a,e){if(e.autoGitPush)try{node_child_process.execSync("git push",{cwd:a}),e.createGitTag&&node_child_process.execSync("git push --tags",{cwd:a}),consola.consola.success("Pushed changes to remote")}catch(o){consola.consola.warn("Failed to push changes:",o)}}async function publishPackage(a,e={}){const{config:o}=await utils.loadConfig({cwd:a}),s=o.publish||{},p=await pkgTypes.readPackageJSON(a),{name:i,version:c}=p;if(!i||!c)throw new Error("Missing name or version in package.json");if(!g__default.valid(c))throw new Error(`Invalid version format in package.json: ${c}`);const u=await nypm.detectPackageManager(a),l=u?.command||"npm";await k(a,s,e);let n;if(e.tag)n=e.tag;else if(e.stable||e.latest)n=s.stableTag||"latest";else if(g__default.prerelease(c)){const t=g__default.prerelease(c);n=t&&t[0]||s.defaultTag||"edge"}else n=s.stableTag||"latest";consola.consola.info(`Publishing ${i}@${c} to tag: ${n}`);const d=["publish","--tag",n,"--access",e.access||s.access||"public"];(e.registry||s.registry)&&d.push("--registry",e.registry||s.registry||""),e.dryRun&&d.push("--dry-run");const h=`${l} ${d.join(" ")}`;consola.consola.start("Publishing package...");try{if(node_child_process.execSync(h,{cwd:a,stdio:"inherit"}),e.dryRun)consola.consola.success("Dry run completed successfully");else{consola.consola.success(`Published ${i}@${c} to ${n}`);const t=s.defaultTag||"edge";if(n!==t){consola.consola.start(`Also publishing to ${t} tag...`);try{let r;u?.name==="yarn"?r=`${l} tag add ${i}@${c} ${t}`:r=`${l} dist-tag add ${i}@${c} ${t}`,node_child_process.execSync(r,{cwd:a,stdio:"inherit"}),consola.consola.success(`Also published ${i}@${c} to ${t}`)}catch(r){consola.consola.warn(`Failed to add ${t} tag:`,r)}}await C(a,s)}return{packageName:i,version:c,publishTag:n,dryRun:e.dryRun||!1}}catch(t){throw consola.consola.error("Failed to publish package:",t),t}}exports.publishPackage=publishPackage;

package/dist/shared/basis.BEOfVK6U.cjs

@@ -0,0 +1,3 @@
+"use strict";const node_child_process=require("node:child_process"),consola=require("consola"),P=require("fast-glob"),$=require("micromatch"),nypm=require("nypm"),pathe=require("pathe"),pkgTypes=require("pkg-types"),utils=require("./basis.BJhSbOyA.cjs");function _interopDefaultCompat(e){return e&&typeof e=="object"&&"default"in e?e.default:e}const P__default=_interopDefaultCompat(P),$__default=_interopDefaultCompat($);function getStagedFiles(){try{const e=node_child_process.execSync("git diff --cached --name-only",{encoding:"utf8"}).trim().split(`
+`).filter(Boolean),i=node_child_process.execSync("git diff --cached --name-only --diff-filter=D",{encoding:"utf8"}),s=new Set(i.trim().split(`
+`).filter(Boolean));return e.filter(n=>!s.has(n))}catch{return[]}}async function getProjectFiles(e,i=["**/*"],s=["node_modules/**","dist/**","build/**",".git/**"]){try{return await P__default(i,{cwd:e,ignore:s,onlyFiles:!0,dot:!1,absolute:!1})}catch(n){return consola.consola.warn("Failed to scan project files:",n),[]}}async function lintStaged(e=process.cwd(),i){const{config:s}=await utils.loadConfig({cwd:e,overrides:i?{lint:{staged:i}}:void 0}),n=s.lint?.staged||{},c=getStagedFiles();if(c.length===0)return consola.consola.info("No staged files to lint"),!0;if(Object.keys(n).length===0)return consola.consola.warn("No staged lint configuration found"),!0;let o=!1;const t=new Set;for(const[d,u]of Object.entries(n)){const r=c.filter(l=>!t.has(l)&&$__default.isMatch(l.split("/").pop()||l,d));if(r.length!==0){consola.consola.start(`Linting ${r.length} files: ${d}`);try{const l=`${u} ${r.join(" ")}`;node_child_process.execSync(l,{stdio:"inherit",cwd:e});const f=[];for(const a of r)await utils.fileExists(pathe.resolve(e,a))&&f.push(a);f.length>0&&node_child_process.execSync(`git add ${f.join(" ")}`,{stdio:"inherit",cwd:e}),r.forEach(a=>t.add(a)),consola.consola.success(`${d}`)}catch(l){o=!0,consola.consola.error(`${d} failed:`,l)}}}return!o}async function lintProject(e=process.cwd(),i){const{config:s}=await utils.loadConfig({cwd:e,overrides:i?{lint:{project:i}}:void 0}),n=s.lint?.project||{};if(Object.keys(n).length===0)return consola.consola.warn("No project lint configuration found"),!0;consola.consola.start("Running project-wide linting...");let c=!1;for(const[o,t]of Object.entries(n)){consola.consola.start(`Running project lint: ${o}`);try{node_child_process.execSync(t,{stdio:"inherit",cwd:e}),consola.consola.success(`${o}`)}catch(d){c=!0,consola.consola.error(`${o} failed:`,d)}}return!c}async function lintDependencies(e=process.cwd(),i){const{config:s}=await utils.loadConfig({cwd:e,overrides:i?{lint:{dependencies:i}}:void 0}),n=s.lint?.dependencies||{};let c=!1;try{const o=await pkgTypes.readPackageJSON(e),t={...o.dependencies,...o.devDependencies},d=(await nypm.detectPackageManager(e))?.name||"npm",u=utils.getPackageManagerCommands(d);if(consola.consola.start("Checking dependencies..."),n.blockedPackages&&n.blockedPackages.length>0){const r=Object.keys(t).filter(l=>n.blockedPackages?.includes(l));r.length>0?(consola.consola.error(`Blocked packages found: ${r.join(", ")}`),c=!0):consola.consola.success("No blocked packages found")}if(n.checkOutdated)try{node_child_process.execSync(u.outdated,{cwd:e,stdio:"pipe"}),consola.consola.success("All dependencies are up to date")}catch(r){consola.consola.warn("\u26A0 Some dependencies are outdated:",r)}if(n.checkSecurity)try{node_child_process.execSync(u.audit,{cwd:e,stdio:"pipe"}),consola.consola.success("No security vulnerabilities found")}catch(r){consola.consola.error("Security vulnerabilities detected:",r),c=!0}n.allowedLicenses&&n.allowedLicenses.length>0&&consola.consola.info("\u{1F4DD} License checking requires manual review or additional tooling")}catch(o){consola.consola.error("Failed to check dependencies:",o),c=!0}return!c}async function lintStructure(e=process.cwd(),i){const{config:s}=await utils.loadConfig({cwd:e,overrides:i?{lint:{structure:i}}:void 0}),n=s.lint?.structure||{};let c=!1;if(consola.consola.start("Checking project structure..."),n.requiredFiles)for(const o of n.requiredFiles){const t=pathe.resolve(e,o);await utils.fileExists(t)?consola.consola.success(`Required file found: ${o}`):(consola.consola.error(`Required file missing: ${o}`),c=!0)}if(n.requiredDirs)for(const o of n.requiredDirs){const t=pathe.resolve(e,o);await utils.fileExists(t)?consola.consola.success(`Required directory found: ${o}`):(consola.consola.error(`Required directory missing: ${o}`),c=!0)}if(n.naming&&n.naming.length>0)for(const o of n.naming){const{path:t,files:d,directories:u,description:r}=o;consola.consola.start(`Checking naming rule: ${r||t}`);const l=await getProjectFiles(e,[t]);if(d){const f=new RegExp(d),a=l.filter(p=>{const g=p.split("/").pop()||"";return!f.test(g)});a.length>0?(consola.consola.error(`Files with invalid naming in ${t}: ${a.slice(0,3).join(", ")}${a.length>3?"...":""}`),c=!0):l.length>0&&consola.consola.success(`All files in ${t} follow naming convention`)}if(u){const f=new RegExp(u),a=new Set;l.forEach(g=>{const h=g.split("/");h.pop(),h.forEach(w=>a.add(w))});const p=Array.from(a).filter(g=>!f.test(g));p.length>0?(consola.consola.error(`Directories with invalid naming in ${t}: ${p.slice(0,3).join(", ")}`),c=!0):a.size>0&&consola.consola.success(`All directories in ${t} follow naming convention`)}}return!c}async function lintDocs(e=process.cwd(),i){const{config:s}=await utils.loadConfig({cwd:e,overrides:i?{lint:{docs:i}}:void 0}),n=s.lint?.docs||{};let c=!1;if(consola.consola.start("Checking documentation..."),n.checkReadme!==!1){const o=["README.md","README.rst","README.txt","readme.md"];(await Promise.all(o.map(t=>utils.fileExists(pathe.resolve(e,t))))).some(t=>t)?consola.consola.success("README file found"):(consola.consola.error("No README file found"),c=!0)}if(n.checkChangelog){const o=["CHANGELOG.md","CHANGELOG.rst","HISTORY.md","changelog.md"];(await Promise.all(o.map(t=>utils.fileExists(pathe.resolve(e,t))))).some(t=>t)?consola.consola.success("CHANGELOG file found"):(consola.consola.error("No CHANGELOG file found"),c=!0)}return!c}async function lintAll(e=process.cwd()){const{config:i}=await utils.loadConfig({cwd:e}),s=i.lint||{};consola.consola.start("Running comprehensive project lint...");const n=(await Promise.allSettled([lintProject(e,s.project),lintDependencies(e,s.dependencies),lintStructure(e,s.structure),lintDocs(e,s.docs)])).filter(c=>c.status==="rejected"||c.status==="fulfilled"&&!c.value);return n.length===0?(consola.consola.success("All lint checks passed!"),!0):(consola.consola.error(`${n.length} lint check(s) failed`),!1)}exports.getProjectFiles=getProjectFiles,exports.getStagedFiles=getStagedFiles,exports.lintAll=lintAll,exports.lintDependencies=lintDependencies,exports.lintDocs=lintDocs,exports.lintProject=lintProject,exports.lintStaged=lintStaged,exports.lintStructure=lintStructure;

package/dist/shared/basis.BJhSbOyA.cjs

@@ -0,0 +1 @@
+"use strict";const promises=require("node:fs/promises"),c12=require("c12"),config=require("../config.cjs");async function loadConfig(e={}){return await c12.loadConfig({name:"basis",cwd:process.cwd(),...e,defaults:{...config.defaultConfig,...e.defaults}})}async function fileExists(e){try{return await promises.access(e),!0}catch{return!1}}function getPackageManagerCommands(e){switch(e){case"yarn":return{outdated:"yarn outdated --json",audit:"yarn audit --level moderate"};case"pnpm":return{outdated:"pnpm outdated --format table",audit:"pnpm audit --audit-level moderate"};case"bun":return{outdated:"bun outdated",audit:"bun audit --audit-level moderate"};default:return{outdated:"npm outdated --json",audit:"npm audit --audit-level moderate"}}}exports.fileExists=fileExists,exports.getPackageManagerCommands=getPackageManagerCommands,exports.loadConfig=loadConfig;

package/dist/shared/basis.BvLeB_5F.d.cts

@@ -0,0 +1,253 @@
+interface BasisConfig {
+    lint?: LintConfig;
+    git?: GitConfig;
+    packageManager?: PackageManagerConfig;
+    version?: VersionConfig;
+    publish?: PublishConfig;
+}
+interface LintConfig {
+    staged?: Record<string, string>;
+    project?: Record<string, string>;
+    dependencies?: {
+        checkOutdated?: boolean;
+        checkSecurity?: boolean;
+        allowedLicenses?: string[];
+        blockedPackages?: string[];
+    };
+    structure?: {
+        requiredFiles?: string[];
+        requiredDirs?: string[];
+        naming?: Array<{
+            path: string;
+            files?: string;
+            directories?: string;
+            description?: string;
+        }>;
+    };
+    docs?: {
+        checkReadme?: boolean;
+        checkChangelog?: boolean;
+    };
+}
+interface GitConfig {
+    hooks?: Partial<Record<ValidGitHook, string>>;
+    config?: {
+        core?: {
+            editor?: string;
+            autocrlf?: boolean | "input";
+            eol?: "lf" | "crlf" | "native";
+            ignorecase?: boolean;
+            filemode?: boolean;
+            bare?: boolean;
+            logallrefupdates?: boolean;
+            repositoryformatversion?: number;
+            sharedrepository?: boolean | "group" | "all" | "world" | "everybody";
+            worktree?: string;
+            precomposeunicode?: boolean;
+            protecthfs?: boolean;
+            protectntfs?: boolean;
+        };
+        user?: {
+            name?: string;
+            email?: string;
+            signingkey?: string;
+        };
+        init?: {
+            defaultBranch?: string;
+        };
+        branch?: {
+            autosetupmerge?: boolean | "always";
+            autosetuprebase?: "never" | "local" | "remote" | "always";
+        };
+        push?: {
+            default?: "nothing" | "current" | "upstream" | "simple" | "matching";
+            followTags?: boolean;
+            autoSetupRemote?: boolean;
+        };
+        pull?: {
+            rebase?: boolean | "preserve" | "merges" | "interactive";
+            ff?: boolean | "only";
+        };
+        merge?: {
+            tool?: string;
+            conflictstyle?: "merge" | "diff3";
+            ff?: boolean | "only";
+            log?: boolean | number;
+        };
+        rebase?: {
+            autoSquash?: boolean;
+            autoStash?: boolean;
+            updateRefs?: boolean;
+        };
+        fetch?: {
+            prune?: boolean;
+            pruneTags?: boolean;
+            fsckobjects?: boolean;
+        };
+        remote?: {
+            [remoteName: string]: {
+                url?: string;
+                fetch?: string;
+            };
+        };
+        diff?: {
+            tool?: string;
+            algorithm?: "myers" | "minimal" | "patience" | "histogram";
+            renames?: boolean | "copy" | "copies";
+            mnemonicprefix?: boolean;
+        };
+        status?: {
+            showUntrackedFiles?: "no" | "normal" | "all";
+            branch?: boolean;
+            short?: boolean;
+        };
+        commit?: {
+            cleanup?: "strip" | "whitespace" | "verbatim" | "scissors" | "default";
+            gpgsign?: boolean;
+            template?: string;
+            verbose?: boolean;
+        };
+        log?: {
+            abbrevCommit?: boolean;
+            decorate?: boolean | "short" | "full" | "auto" | "no";
+            showSignature?: boolean;
+        };
+        transfer?: {
+            fsckobjects?: boolean;
+        };
+        receive?: {
+            fsckObjects?: boolean;
+        };
+        gc?: {
+            auto?: number;
+            autopacklimit?: number;
+            autodetach?: boolean;
+        };
+        alias?: {
+            [aliasName: string]: string;
+        };
+        url?: {
+            [pattern: string]: {
+                insteadOf?: string;
+                pushInsteadOf?: string;
+            };
+        };
+    };
+    commitMsg?: CommitMsgConfig;
+    autoSetup?: boolean;
+    autoInitGit?: boolean;
+    skipGitCheck?: boolean;
+    force?: boolean;
+}
+interface CommitMsgConfig {
+    types?: string[];
+    maxLength?: number;
+    minLength?: number;
+    scopeRequired?: boolean;
+    allowedScopes?: string[];
+}
+interface CommitMessage {
+    type: string;
+    scope?: string;
+    description: string;
+    body?: string;
+    footer?: string;
+    isBreaking: boolean;
+}
+declare const VALID_GIT_HOOKS: readonly ["applypatch-msg", "pre-applypatch", "post-applypatch", "pre-commit", "pre-merge-commit", "prepare-commit-msg", "commit-msg", "post-commit", "pre-rebase", "post-checkout", "post-merge", "pre-push", "pre-receive", "update", "proc-receive", "post-receive", "post-update", "reference-transaction", "push-to-checkout", "pre-auto-gc", "post-rewrite", "sendemail-validate", "fsmonitor-watchman", "p4-changelist", "p4-prepare-changelist", "p4-post-changelist", "p4-pre-submit", "post-index-change"];
+type ValidGitHook = (typeof VALID_GIT_HOOKS)[number];
+type GitConfigValue = string | number | boolean;
+type GitConfigSection = Record<string, GitConfigValue>;
+type GitConfigData = Record<string, GitConfigSection>;
+interface PackageManagerConfig {
+    /** Preferred package manager (aligned with nypm support) */
+    preferred?: "npm" | "yarn" | "pnpm" | "bun" | "deno";
+    /** Auto-detect package manager from project */
+    autoDetect?: boolean;
+    /** NPM registry URL */
+    registry?: string;
+}
+interface VersionConfig {
+    /** Git tag prefix */
+    tagPrefix?: string;
+    /** Auto commit version changes */
+    autoCommit?: boolean;
+    /** Auto create git tag */
+    autoTag?: boolean;
+    /** Auto push changes to remote */
+    autoPush?: boolean;
+    /** Prerelease identifier (alpha, beta, rc) */
+    prereleaseId?: string;
+    /** Commit message template */
+    commitMessage?: string;
+}
+interface PublishConfig {
+    /** NPM registry URL */
+    registry?: string;
+    /** Package access level */
+    access?: "public" | "private";
+    /** Default publish tag (for non-stable releases) */
+    defaultTag?: string;
+    /** Stable release tag */
+    stableTag?: string;
+    /** Build command before publish */
+    buildCommand?: string;
+    /** Test command before publish */
+    testCommand?: string;
+    /** Check git working directory is clean */
+    checkGitClean?: boolean;
+    /** Run tests before publish */
+    checkTests?: boolean;
+    /** Auto push git changes after publish */
+    autoGitPush?: boolean;
+    /** Create git tag after publish */
+    createGitTag?: boolean;
+}
+interface InitOptions {
+    force?: boolean;
+    skipGitCheck?: boolean;
+    skipInstall?: boolean;
+}
+interface VersionOptions {
+    version?: string;
+    preid?: string;
+    prerelease?: boolean;
+    major?: boolean;
+    minor?: boolean;
+    patch?: boolean;
+    tag?: string;
+    message?: string;
+}
+interface PublishOptions {
+    tag?: string;
+    stable?: boolean;
+    latest?: boolean;
+    dryRun?: boolean;
+    access?: "public" | "private";
+    registry?: string;
+    skipBuild?: boolean;
+    skipTests?: boolean;
+}
+interface VersionUpdateResult {
+    oldVersion: string;
+    newVersion: string;
+    tagName?: string;
+}
+interface PublishResult {
+    packageName: string;
+    version: string;
+    publishTag: string;
+    dryRun: boolean;
+}
+
+/**
+ * Define a Basis configuration
+ */
+declare function defineBasisConfig(config: BasisConfig): BasisConfig;
+/**
+ * Default configuration
+ */
+declare const defaultConfig: BasisConfig;
+
+export { defineBasisConfig as d, defaultConfig as e, VALID_GIT_HOOKS as g };
+export type { BasisConfig as B, CommitMessage as C, GitConfig as G, InitOptions as I, LintConfig as L, PublishOptions as P, VersionOptions as V, VersionUpdateResult as a, PublishResult as b, GitConfigData as c, CommitMsgConfig as f, ValidGitHook as h, GitConfigValue as i, GitConfigSection as j, PackageManagerConfig as k, VersionConfig as l, PublishConfig as m };