devvami 1.0.0

package/package.json

@@ -0,0 +1,161 @@
+{
+  "name": "devvami",
+  "description": "DevEx CLI for developers and teams — manage repos, PRs, pipelines, tasks, and costs from the terminal",
+  "version": "1.0.0",
+  "author": "",
+  "type": "module",
+  "bin": {
+    "dvmi": "./bin/run.js"
+  },
+  "packageManager": "pnpm@10.32.1",
+  "engines": {
+    "node": ">=24.0.0",
+    "pnpm": ">=10"
+  },
+  "license": "MIT",
+  "files": [
+    "./bin",
+    "./src",
+    "./oclif.manifest.json"
+  ],
+  "main": "src/index.js",
+  "oclif": {
+    "bin": "dvmi",
+    "dirname": "dvmi",
+    "commands": "./src/commands",
+    "helpClass": "./src/help.js",
+    "plugins": [
+      "@oclif/plugin-help",
+      "@oclif/plugin-autocomplete"
+    ],
+    "hooks": {
+      "init": "./src/hooks/init.js",
+      "postrun": "./src/hooks/postrun.js"
+    },
+    "topicSeparator": " ",
+    "theme": {
+      "sectionHeader": "#FF6B2B",
+      "sectionDescription": "#FFFFFF",
+      "bin": "#FF9A5C",
+      "command": "#FF9A5C",
+      "commandSummary": "#CCCCCC",
+      "topic": "#FF9A5C",
+      "version": "#4A9EFF",
+      "dollarSign": "#FF6B2B",
+      "flag": "#4A9EFF",
+      "flagSeparator": "#888888",
+      "flagDefaultValue": "#888888",
+      "flagOptions": "#888888",
+      "flagRequired": "#FF6B2B",
+      "alias": "#888888"
+    },
+    "topics": {
+      "auth": {
+        "description": "🔑 GitHub and AWS authentication"
+      },
+      "create": {
+        "description": "🏗️  Create projects from templates"
+      },
+      "branch": {
+        "description": "🌿 Branch management with naming conventions"
+      },
+      "pr": {
+        "description": "🔀 Pull Request workflow"
+      },
+      "repo": {
+        "description": "📁 GitHub repository management"
+      },
+      "pipeline": {
+        "description": "⚙️  GitHub Actions monitoring"
+      },
+      "tasks": {
+        "description": "✅ Task management"
+      },
+      "costs": {
+        "description": "💰 AWS cost analysis"
+      },
+      "docs": {
+        "description": "📖 Repository documentation"
+      }
+    }
+  },
+  "dependencies": {
+    "@aws-sdk/client-cost-explorer": "^3",
+    "@inquirer/prompts": "^7",
+    "@oclif/core": "^4",
+    "@oclif/plugin-autocomplete": "^3",
+    "@oclif/plugin-help": "^6",
+    "chalk": "^5",
+    "execa": "^9",
+    "figlet": "^1",
+    "js-yaml": "^4.1.1",
+    "keytar": "^7",
+    "marked": "^9.1.6",
+    "octokit": "^4",
+    "open": "^10",
+    "ora": "^8",
+    "pako": "^2.1.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19",
+    "@commitlint/config-conventional": "^19",
+    "@commitlint/types": "^19",
+    "@eslint/compat": "^1",
+    "@semantic-release/changelog": "^6",
+    "@semantic-release/git": "^10",
+    "@semantic-release/github": "^10",
+    "@vitest/coverage-v8": "^3",
+    "commitizen": "^4",
+    "conventional-changelog-conventionalcommits": "^8",
+    "cz-git": "^1",
+    "eslint": "^9",
+    "eslint-config-prettier": "^10",
+    "eslint-plugin-jsdoc": "^50",
+    "lefthook": "^1",
+    "memfs": "^4",
+    "msw": "^2",
+    "oclif": "^4",
+    "prettier": "^3",
+    "semantic-release": "^24",
+    "shx": "^0.4.0",
+    "strip-ansi": "^7",
+    "vitest": "^3"
+  },
+  "scripts": {
+    "commit": "git-cz",
+    "release": "semantic-release",
+    "release:dry-run": "semantic-release --dry-run",
+    "lint": "eslint src/ tests/",
+    "lint:fix": "eslint src/ tests/ --fix",
+    "format": "prettier --write src/ tests/",
+    "test": "vitest run",
+    "test:unit": "vitest run --project unit",
+    "test:services": "vitest run --project services",
+    "test:integration": "vitest run --project integration",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepack": "oclif manifest",
+    "postpack": "shx rm -f oclif.manifest.json",
+    "prepare": "lefthook install"
+  },
+  "config": {
+    "commitizen": {
+      "path": "cz-git"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/savez/devvami"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild",
+      "keytar",
+      "msw"
+    ]
+  }
+}

package/src/commands/auth/login.js

@@ -0,0 +1,89 @@
+import { Command, Flags } from '@oclif/core'
+import chalk from 'chalk'
+import ora from 'ora'
+import { checkGitHubAuth, loginGitHub, checkAWSAuth, loginAWS } from '../../services/auth.js'
+import { loadConfig } from '../../services/config.js'
+
+export default class AuthLogin extends Command {
+  static description = 'Autenticazione centralizzata GitHub + AWS'
+
+  static examples = [
+    '<%= config.bin %> auth login',
+    '<%= config.bin %> auth login --github',
+    '<%= config.bin %> auth login --aws',
+  ]
+
+  static enableJsonFlag = true
+
+  static flags = {
+    github: Flags.boolean({ description: 'Solo autenticazione GitHub', default: false }),
+    aws: Flags.boolean({ description: 'Solo autenticazione AWS', default: false }),
+    verbose: Flags.boolean({ description: 'Output dettagliato', default: false }),
+  }
+
+  async run() {
+    const { flags } = await this.parse(AuthLogin)
+    const isJson = flags.json
+    const doGitHub = !flags.aws || flags.github
+    const doAWS = !flags.github || flags.aws
+
+    const result = { github: null, aws: null }
+
+    // GitHub auth
+    if (doGitHub) {
+      const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Checking GitHub auth...') }).start()
+      let ghStatus = await checkGitHubAuth()
+
+      if (ghStatus.authenticated) {
+        spinner?.succeed(`GitHub: already authenticated as @${ghStatus.username}`)
+        result.github = { status: 'ok', username: ghStatus.username, org: '' }
+      } else {
+        if (spinner) spinner.text = 'Logging in to GitHub...'
+        ghStatus = await loginGitHub()
+        if (ghStatus.authenticated) {
+          spinner?.succeed(`GitHub: authenticated as @${ghStatus.username}`)
+          result.github = { status: 'ok', username: ghStatus.username, org: '' }
+        } else {
+          spinner?.fail('GitHub authentication failed')
+          result.github = { status: 'error', error: ghStatus.error }
+        }
+      }
+    }
+
+    // AWS auth
+    if (doAWS) {
+      const config = await loadConfig()
+      const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Checking AWS auth...') }).start()
+      let awsStatus = await checkAWSAuth()
+
+      if (awsStatus.authenticated) {
+        spinner?.succeed(`AWS: session active for account ${awsStatus.account}`)
+        result.aws = { status: 'ok', account: awsStatus.account, role: awsStatus.role }
+      } else {
+        if (spinner) spinner.text = 'Logging in to AWS via aws-vault...'
+        awsStatus = await loginAWS(config.awsProfile || 'default')
+        if (awsStatus.authenticated) {
+          spinner?.succeed(`AWS: logged in to account ${awsStatus.account}`)
+          result.aws = { status: 'ok', account: awsStatus.account, role: awsStatus.role }
+        } else {
+          spinner?.fail('AWS authentication failed')
+          result.aws = { status: 'error', error: awsStatus.error }
+        }
+      }
+    }
+
+    if (isJson) return result
+
+    this.log('\n' + chalk.green('Authentication complete'))
+    if (result.github) {
+      const icon = result.github.status === 'ok' ? chalk.green('✓') : chalk.red('✗')
+      this.log(`  ${icon} GitHub: @${result.github.username ?? 'error'}`)
+    }
+    if (result.aws) {
+      const icon = result.aws.status === 'ok' ? chalk.green('✓') : chalk.red('✗')
+      this.log(`  ${icon} AWS: account ${result.aws.account ?? 'error'}`)
+    }
+
+    return result
+  }
+}

package/src/commands/changelog.js

@@ -0,0 +1,102 @@
+import { Command, Flags } from '@oclif/core'
+import { writeFile } from 'node:fs/promises'
+import { exec } from '../services/shell.js'
+
+/**
+ * Parse a conventional commit message.
+ * @param {string} message
+ * @returns {{ type: string, scope: string, description: string }|null}
+ */
+function parseConventionalCommit(message) {
+  const match = message.match(/^(\w+)(?:\(([^)]+)\))?!?: (.+)/)
+  if (!match) return null
+  return { type: match[1], scope: match[2] ?? '', description: match[3] }
+}
+
+export default class Changelog extends Command {
+  static description = 'Genera changelog da Conventional Commits'
+
+  static examples = [
+    '<%= config.bin %> changelog',
+    '<%= config.bin %> changelog --from v1.0.0',
+    '<%= config.bin %> changelog --output CHANGELOG.md',
+  ]
+
+  static enableJsonFlag = true
+
+  static flags = {
+    from: Flags.string({ description: 'Tag o commit di partenza (default: ultimo tag)' }),
+    to: Flags.string({ description: 'Commit finale (default: HEAD)', default: 'HEAD' }),
+    output: Flags.string({ description: 'Scrivi su file (default: stdout)' }),
+  }
+
+  async run() {
+    const { flags } = await this.parse(Changelog)
+    const isJson = flags.json
+
+    // Determine from ref
+    let from = flags.from
+    if (!from) {
+      const tagResult = await exec('git', ['describe', '--tags', '--abbrev=0'])
+      from = tagResult.exitCode === 0 ? tagResult.stdout : ''
+    }
+
+    // Get commits
+    const range = from ? `${from}..${flags.to}` : flags.to
+    const logResult = await exec('git', ['log', range, '--format=%s|%H'])
+    if (logResult.exitCode !== 0) {
+      this.error('Failed to read git log. Are you in a git repository?')
+    }
+
+    const lines = logResult.stdout.split('\n').filter(Boolean)
+
+    /** @type {Record<string, Array<{ message: string, hash: string }>>} */
+    const sections = { feat: [], fix: [], chore: [], docs: [], refactor: [], test: [], other: [] }
+
+    for (const line of lines) {
+      const [message, hash] = line.split('|')
+      const parsed = parseConventionalCommit(message)
+      const type = parsed?.type ?? 'other'
+      const entry = { message: message.trim(), hash: hash?.slice(0, 7) ?? '' }
+      if (type in sections) {
+        sections[type].push(entry)
+      } else {
+        sections.other.push(entry)
+      }
+    }
+
+    if (isJson) return { from: from || 'beginning', to: flags.to, sections }
+
+    // Build markdown
+    const title = `## [Unreleased]${from ? ` (since ${from})` : ''}`
+    const parts = [title, '']
+
+    const sectionTitles = {
+      feat: '### Features',
+      fix: '### Bug Fixes',
+      chore: '### Chores',
+      docs: '### Documentation',
+      refactor: '### Refactoring',
+      test: '### Tests',
+      other: '### Other',
+    }
+
+    for (const [type, entries] of Object.entries(sections)) {
+      if (entries.length === 0) continue
+      parts.push(sectionTitles[type])
+      for (const e of entries) parts.push(`- ${e.message}`)
+      parts.push('')
+    }
+
+    const output = parts.join('\n')
+
+    if (flags.output) {
+      await writeFile(flags.output, output, 'utf8')
+      this.log(`Changelog written to ${flags.output}`)
+    } else {
+      this.log(output)
+    }
+
+    return { from: from || 'beginning', to: flags.to, sections }
+  }
+}

package/src/commands/costs/get.js

@@ -0,0 +1,73 @@
+import { Command, Args, Flags } from '@oclif/core'
+import ora from 'ora'
+import { getServiceCosts } from '../../services/aws-costs.js'
+import { loadConfig } from '../../services/config.js'
+import { formatCostTable, calculateTotal } from '../../formatters/cost.js'
+
+export default class CostsGet extends Command {
+  static description = 'Stima costi AWS per un servizio (via Cost Explorer API)'
+
+  static examples = [
+    '<%= config.bin %> costs get my-service',
+    '<%= config.bin %> costs get my-api --period mtd',
+    '<%= config.bin %> costs get my-service --json',
+  ]
+
+  static enableJsonFlag = true
+
+  static args = {
+    service: Args.string({ description: 'Nome del servizio', required: true }),
+  }
+
+  static flags = {
+    period: Flags.string({
+      description: 'Periodo: last-month, last-week, mtd',
+      default: 'last-month',
+      options: ['last-month', 'last-week', 'mtd'],
+    }),
+  }
+
+  async run() {
+    const { args, flags } = await this.parse(CostsGet)
+    const isJson = flags.json
+
+    const spinner = isJson ? null : ora(`Fetching costs for ${args.service}...`).start()
+
+    // Get project tags from config
+    const config = await loadConfig()
+    const tags = config.projectTags ?? { project: args.service }
+
+    try {
+      const { entries, period } = await getServiceCosts(args.service, tags, /** @type {any} */ (flags.period))
+      spinner?.stop()
+
+      const total = calculateTotal(entries)
+      const result = {
+        service: args.service,
+        period,
+        items: entries,
+        total: { amount: total, unit: 'USD' },
+      }
+
+      if (isJson) return result
+
+      if (entries.length === 0) {
+        this.log(`No costs found for service "${args.service}".`)
+        this.log('Check service name and tagging convention.')
+        return result
+      }
+
+      this.log(formatCostTable(entries, args.service))
+      return result
+    } catch (err) {
+      spinner?.stop()
+      if (String(err).includes('AccessDenied') || String(err).includes('UnauthorizedAccess')) {
+        this.error('Missing IAM permission: ce:GetCostAndUsage\nContact your AWS admin to grant Cost Explorer access.')
+      }
+       if (String(err).includes('CredentialsProviderError') || String(err).includes('No credentials')) {
+         this.error('No AWS credentials. Use: aws-vault exec <profile> -- dvmi costs get ' + args.service)
+       }
+      throw err
+    }
+  }
+}

package/src/commands/create/repo.js

@@ -0,0 +1,196 @@
+import { Command, Args, Flags } from '@oclif/core'
+import chalk from 'chalk'
+import ora from 'ora'
+import { input, confirm } from '@inquirer/prompts'
+import { listTemplates, createFromTemplate, setBranchProtection, enableDependabot } from '../../services/github.js'
+import { loadConfig } from '../../services/config.js'
+import { validateRepoName } from '../../validators/repo-name.js'
+import { renderTable } from '../../formatters/table.js'
+import { exec } from '../../services/shell.js'
+
+/**
+ * @param {string} lang
+ * @returns {string}
+ */
+function langColor(lang) {
+  const map = {
+    javascript: chalk.yellow,
+    typescript: chalk.blue,
+    python:     chalk.green,
+    java:       chalk.red,
+    go:         chalk.cyan,
+    ruby:       chalk.magenta,
+    rust:       chalk.hex('#CE422B'),
+    kotlin:     chalk.hex('#7F52FF'),
+    swift:      chalk.hex('#F05138'),
+    php:        chalk.hex('#777BB4'),
+    shell:      chalk.greenBright,
+  }
+  const fn = map[lang.toLowerCase()]
+  return fn ? fn(lang) : chalk.dim(lang)
+}
+
+export default class CreateRepo extends Command {
+  static description = 'Crea nuovo progetto da template GitHub o lista i template disponibili'
+
+  static examples = [
+    '<%= config.bin %> create repo --list',
+    '<%= config.bin %> create repo --list --search "lambda"',
+    '<%= config.bin %> create repo template-lambda',
+    '<%= config.bin %> create repo template-lambda --name my-service --dry-run',
+  ]
+
+  static enableJsonFlag = true
+
+  static args = {
+    template: Args.string({ description: 'Nome del template', required: false }),
+  }
+
+  static flags = {
+    list:        Flags.boolean({ description: 'Lista template disponibili', default: false }),
+    search:      Flags.string({ char: 's', description: 'Cerca in nome e descrizione dei template (case-insensitive)' }),
+    name:        Flags.string({ description: 'Nome del nuovo repository' }),
+    description: Flags.string({ description: 'Descrizione del repository', default: '' }),
+    private:     Flags.boolean({ description: 'Repository privato (default)', default: true }),
+    public:      Flags.boolean({ description: 'Repository pubblico', default: false }),
+    'dry-run':   Flags.boolean({ description: 'Preview senza eseguire', default: false }),
+  }
+
+  async run() {
+    const { args, flags } = await this.parse(CreateRepo)
+    const isJson = flags.json
+    const isDryRun = flags['dry-run']
+    const config = await loadConfig()
+
+    if (!config.org) {
+      this.error('GitHub org not configured. Run `dvmi init` to set up your environment.')
+    }
+
+    // --list mode
+    if (flags.list || !args.template) {
+      const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Fetching templates...') }).start()
+      const templates = await listTemplates(config.org)
+      spinner?.stop()
+
+      // Search filter
+      const searchQuery = flags.search?.toLowerCase()
+      const filtered = searchQuery
+        ? templates.filter((t) =>
+            t.name.toLowerCase().includes(searchQuery) ||
+            t.description.toLowerCase().includes(searchQuery),
+          )
+        : templates
+
+      if (isJson) return { templates: filtered }
+
+      if (templates.length === 0) {
+        this.log(chalk.yellow('No templates found in the organization.'))
+        this.log(chalk.dim('Templates are GitHub repos marked as "Template repository".'))
+        return { templates: [] }
+      }
+
+      if (filtered.length === 0) {
+        this.log(chalk.dim(`No templates matching "${flags.search}".`))
+        return { templates: [] }
+      }
+
+      const filterInfo = flags.search
+        ? chalk.dim('  —  search: ') + chalk.white(`"${flags.search}"`)
+        : ''
+
+      this.log(
+        chalk.bold('\nAvailable templates') +
+        filterInfo +
+        chalk.dim(`  (${filtered.length}${filtered.length < templates.length ? `/${templates.length}` : ''})`) +
+        '\n',
+      )
+
+      this.log(renderTable(filtered, [
+        { header: 'Name',        key: 'name',        width: 35 },
+        { header: 'Language',    key: 'language',     width: 14, format: (v) => v || '—', colorize: (v) => v === '—' ? chalk.dim(v) : langColor(v) },
+        { header: 'Description', key: 'description',  width: 60, format: (v) => String(v || '—') },
+      ]))
+
+      this.log('')
+      return { templates: filtered }
+    }
+
+    // Create mode
+    const templates = await listTemplates(config.org)
+    const template = templates.find((t) => t.name === args.template)
+    if (!template) {
+      const names = templates.map((t) => t.name).join(', ')
+      this.error(`Template "${args.template}" not found. Available: ${names}`)
+    }
+
+    // Get repo name
+    let repoName = flags.name
+    if (!repoName && !isJson) {
+      repoName = await input({ message: 'Repository name:' })
+    } else if (!repoName) {
+      this.error('--name is required in non-interactive mode')
+    }
+
+    const validation = validateRepoName(repoName)
+    if (!validation.valid) {
+      this.error(`${validation.error}${validation.suggestion ? `\nSuggestion: ${validation.suggestion}` : ''}`)
+    }
+
+    const isPrivate = !flags.public
+
+    if (!isJson && !isDryRun) {
+      const ok = await confirm({
+        message: `Create ${isPrivate ? 'private' : 'public'} repo "${config.org}/${repoName}" from "${args.template}"?`,
+      })
+      if (!ok) { this.log('Aborted.'); return }
+    }
+
+    if (isDryRun) {
+      const preview = {
+        repository: { name: repoName, org: config.org, template: args.template, private: isPrivate },
+        postScaffolding: { branchProtection: 'would configure', dependabot: 'would enable', codeowners: 'would create' },
+      }
+      if (isJson) return preview
+      this.log(chalk.bold('\nDry run preview:'))
+      this.log(JSON.stringify(preview, null, 2))
+      return preview
+    }
+
+    // Create repo
+    const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Creating repository...') }).start()
+    const repo = await createFromTemplate({
+      templateOwner: config.org,
+      templateRepo: args.template,
+      name: repoName,
+      org: config.org,
+      description: flags.description,
+      isPrivate,
+    })
+    spinner?.succeed(`Repository created: ${repo.htmlUrl}`)
+
+    // Post-scaffolding
+    const bpSpinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Configuring branch protection...') }).start()
+    await setBranchProtection(config.org, repoName).catch(() => null)
+    bpSpinner?.succeed('Branch protection configured')
+
+    const depSpinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Enabling Dependabot...') }).start()
+    await enableDependabot(config.org, repoName).catch(() => null)
+    depSpinner?.succeed('Dependabot enabled')
+
+    // Clone
+    const cloneSpinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Cloning repository...') }).start()
+    await exec('gh', ['repo', 'clone', `${config.org}/${repoName}`])
+    cloneSpinner?.succeed(`Cloned to ./${repoName}`)
+
+    const result = {
+      repository: { name: repoName, url: repo.htmlUrl, localPath: `./${repoName}` },
+      postScaffolding: { branchProtection: 'ok', dependabot: 'ok', codeowners: 'ok' },
+    }
+
+    if (!isJson) {
+      this.log('\n' + chalk.green('✓') + ` cd ${repoName} to start working`)
+    }
+
+    return result
+  }
+}