javi-forge 0.1.0 → 1.0.0

package/src/types/index.ts

@@ -1,53 +0,0 @@
-export type Stack = 'node' | 'python' | 'go' | 'rust' | 'java-gradle' | 'java-maven' | 'elixir'
-export type CIProvider = 'github' | 'gitlab' | 'woodpecker'
-export type MemoryOption = 'engram' | 'obsidian-brain' | 'memory-simple' | 'none'
-export interface InitOptions {
-  projectName: string
-  projectDir: string
-  stack: Stack
-  ciProvider: CIProvider
-  memory: MemoryOption
-  aiSync: boolean
-  sdd: boolean
-  ghagga: boolean
-  dryRun: boolean
-}
-
-export interface InitStep {
-  id: string
-  label: string
-  status: 'pending' | 'running' | 'done' | 'error' | 'skipped'
-  detail?: string
-}
-
-export interface StackDetection {
-  stackType: Stack
-  buildTool: string
-  javaVersion?: string
-}
-
-export interface ForgeManifest {
-  version: string
-  projectName: string
-  stack: Stack
-  ciProvider: CIProvider
-  memory: MemoryOption
-  createdAt: string
-  updatedAt: string
-  modules: string[]
-}
-
-export interface DoctorCheck {
-  label: string
-  status: 'ok' | 'fail' | 'skip'
-  detail?: string
-}
-
-export interface DoctorSection {
-  title: string
-  checks: DoctorCheck[]
-}
-
-export interface DoctorResult {
-  sections: DoctorSection[]
-}

package/src/ui/AnalyzeUI.tsx

@@ -1,133 +0,0 @@
-import React, { useEffect, useState } from 'react'
-import { Box, Text, useApp, useInput } from 'ink'
-import Spinner from 'ink-spinner'
-import { runAnalyze } from '../commands/analyze.js'
-import type { InitStep } from '../types/index.js'
-import Header from './Header.js'
-import { theme } from './theme.js'
-import { useCIMode } from './CIContext.js'
-
-interface Props {
-  dryRun: boolean
-}
-
-export default function AnalyzeUI({ dryRun }: Props) {
-  const { exit } = useApp()
-  const isCI = useCIMode()
-  const [steps, setSteps] = useState<InitStep[]>([])
-  const [finished, setFinished] = useState(false)
-  const [startTime] = useState(Date.now())
-
-  useEffect(() => {
-    runAnalyze(
-      process.cwd(),
-      dryRun,
-      (step) => setSteps(prev => {
-        const idx = prev.findIndex(s => s.id === step.id)
-        if (idx >= 0) {
-          const next = [...prev]
-          next[idx] = step
-          return next
-        }
-        return [...prev, step]
-      })
-    ).then(() => setFinished(true))
-  }, [dryRun])
-
-  // Auto-exit in CI mode once finished
-  useEffect(() => {
-    if (isCI && finished) {
-      const t = setTimeout(() => exit(), 100)
-      return () => clearTimeout(t)
-    }
-    return undefined
-  }, [isCI, finished, exit])
-
-  useInput((_, key) => {
-    if (finished && (key.return || key.escape)) exit()
-  }, { isActive: !isCI })
-
-  const doneCount  = steps.filter(s => s.status === 'done').length
-  const errorCount = steps.filter(s => s.status === 'error').length
-  const notInstalled = steps.some(
-    s => s.status === 'error' && s.detail?.includes('not found')
-  )
-  const elapsed = finished
-    ? `${((Date.now() - startTime) / 1000).toFixed(1)}s`
-    : null
-
-  return (
-    <Box flexDirection="column" padding={1}>
-      <Header subtitle="analyze" dryRun={dryRun} />
-
-      {/* Scanning context */}
-      {!finished && steps.length === 0 && (
-        <Box marginLeft={2}>
-          <Text color={theme.warning}>
-            <Spinner type="dots" />
-            {' '}Checking for repoforge...
-          </Text>
-        </Box>
-      )}
-
-      <Box flexDirection="column">
-        {steps.map(step => (
-          <Box key={step.id} marginLeft={2}>
-            {step.status === 'running' ? (
-              <Text color={theme.warning}>
-                <Spinner type="dots" />
-                {' '}{step.label}
-              </Text>
-            ) : step.status === 'done' ? (
-              <Text color={theme.success}>
-                {'\u2713'} {step.label}
-                {step.detail && <Text color={theme.muted} dimColor>  {step.detail}</Text>}
-              </Text>
-            ) : step.status === 'error' ? (
-              <Text color={theme.error}>
-                {'\u2717'} {step.label}
-                {step.detail && <Text color={theme.muted} dimColor>  {step.detail}</Text>}
-              </Text>
-            ) : (
-              <Text color={theme.muted}>
-                {'\u2013'} {step.label}
-                {step.detail && <Text dimColor>  {step.detail}</Text>}
-              </Text>
-            )}
-          </Box>
-        ))}
-      </Box>
-
-      {/* Install instructions when repoforge is missing */}
-      {finished && notInstalled && (
-        <Box marginTop={1} flexDirection="column" marginLeft={2}>
-          <Text color={theme.warning} bold>repoforge is not installed</Text>
-          <Box marginTop={1} flexDirection="column">
-            <Text color={theme.muted}>  Install it with:</Text>
-            <Text color={theme.primary}>    pip install repoforge</Text>
-            <Text color={theme.muted}>  Then run:</Text>
-            <Text color={theme.primary}>    javi-forge analyze</Text>
-          </Box>
-        </Box>
-      )}
-
-      {finished && (
-        <Box marginTop={1} flexDirection="column">
-          <Text bold color={errorCount > 0 ? theme.warning : theme.success}>
-            {dryRun ? '\u25cb Dry run complete' : '\u2713 Analysis complete'}
-            {elapsed && <Text color={theme.muted}>  Completed in {elapsed}</Text>}
-          </Text>
-          {doneCount > 0 && (
-            <Text color={theme.success}>  {'\u2713'} {doneCount} checks passed</Text>
-          )}
-          {errorCount > 0 && (
-            <Text color={theme.error}>  {'\u2717'} {errorCount} errors</Text>
-          )}
-          <Box marginTop={1}>
-            <Text color={theme.muted} dimColor>Press Enter to exit</Text>
-          </Box>
-        </Box>
-      )}
-    </Box>
-  )
-}

package/src/ui/App.tsx

@@ -1,175 +0,0 @@
-import React, { useState } from 'react'
-import { Box } from 'ink'
-import path from 'path'
-import Welcome from './Welcome.js'
-import Header from './Header.js'
-import NameInput from './NameInput.js'
-import StackSelector from './StackSelector.js'
-import CISelector from './CISelector.js'
-import MemorySelector from './MemorySelector.js'
-import OptionSelector from './OptionSelector.js'
-import Progress from './Progress.js'
-import Summary from './Summary.js'
-import { initProject } from '../commands/init.js'
-import type { Stack, CIProvider, MemoryOption, InitStep } from '../types/index.js'
-
-type Stage =
-  | 'welcome'
-  | 'name'
-  | 'stack'
-  | 'ci'
-  | 'memory'
-  | 'options'
-  | 'running'
-  | 'done'
-
-interface AppProps {
-  dryRun?: boolean
-  presetStack?: Stack
-  presetCI?: CIProvider
-  presetMemory?: MemoryOption
-  presetName?: string
-  presetGhagga?: boolean
-}
-
-export default function App({
-  dryRun = false,
-  presetStack,
-  presetCI,
-  presetMemory,
-  presetName,
-  presetGhagga = false,
-}: AppProps) {
-  const [stage, setStage] = useState<Stage>('welcome')
-  const [projectName, setProjectName] = useState(presetName ?? '')
-  const [projectDir, setProjectDir] = useState(
-    presetName ? path.resolve(process.cwd(), presetName) : ''
-  )
-  const [stack, setStack] = useState<Stack>(presetStack ?? 'node')
-  const [ciProvider, setCIProvider] = useState<CIProvider>(presetCI ?? 'github')
-  const [memory, setMemory] = useState<MemoryOption>(presetMemory ?? 'engram')
-  const [aiSync, setAiSync] = useState(true)
-  const [sdd, setSdd] = useState(true)
-  const [ghagga, setGhagga] = useState(presetGhagga)
-  const [steps, setSteps] = useState<InitStep[]>([])
-  const [startTime] = useState(Date.now())
-
-  const handleNameConfirm = (name: string, dir: string) => {
-    setProjectName(name)
-    setProjectDir(dir)
-    setStage(presetStack ? 'ci' : 'stack')
-  }
-
-  const handleStackConfirm = (s: Stack) => {
-    setStack(s)
-    setStage(presetCI ? 'memory' : 'ci')
-  }
-
-  const handleCIConfirm = (p: CIProvider) => {
-    setCIProvider(p)
-    setStage(presetMemory ? 'options' : 'memory')
-  }
-
-  const handleMemoryConfirm = (m: MemoryOption) => {
-    setMemory(m)
-    setStage('options')
-  }
-
-  const handleOptionsConfirm = async (opts: { aiSync: boolean; sdd: boolean; ghagga: boolean }) => {
-    setAiSync(opts.aiSync)
-    setSdd(opts.sdd)
-    setGhagga(opts.ghagga)
-    setStage('running')
-
-    await initProject(
-      {
-        projectName,
-        projectDir,
-        stack,
-        ciProvider,
-        memory,
-        aiSync: opts.aiSync,
-        sdd: opts.sdd,
-        ghagga: opts.ghagga,
-        dryRun,
-      },
-      (step) => setSteps(prev => {
-        const idx = prev.findIndex(s => s.id === step.id)
-        if (idx >= 0) {
-          const next = [...prev]
-          next[idx] = step
-          return next
-        }
-        return [...prev, step]
-      })
-    )
-
-    setStage('done')
-  }
-
-  const subtitle =
-    stage === 'running' ? 'scaffolding...' :
-    stage === 'done'    ? 'complete'       :
-    undefined
-
-  return (
-    <Box flexDirection="column" padding={1}>
-      {stage !== 'welcome' && <Header subtitle={subtitle} dryRun={dryRun} />}
-
-      {stage === 'welcome' && (
-        <Welcome onDone={() => {
-          // Skip stages for which presets are already provided
-          if (presetName && presetStack && presetCI && presetMemory) {
-            setStage('options')
-          } else if (presetName && presetStack && presetCI) {
-            setStage('memory')
-          } else if (presetName && presetStack) {
-            setStage('ci')
-          } else if (presetName) {
-            setStage('stack')
-          } else {
-            setStage('name')
-          }
-        }} />
-      )}
-      {stage === 'name' && (
-        <NameInput
-          defaultName={projectName || 'my-project'}
-          onConfirm={handleNameConfirm}
-        />
-      )}
-      {stage === 'stack' && (
-        <StackSelector
-          projectDir={projectDir || process.cwd()}
-          onConfirm={handleStackConfirm}
-        />
-      )}
-      {stage === 'ci' && (
-        <CISelector onConfirm={handleCIConfirm} />
-      )}
-      {stage === 'memory' && (
-        <MemorySelector onConfirm={handleMemoryConfirm} />
-      )}
-      {stage === 'options' && (
-        <OptionSelector onConfirm={handleOptionsConfirm} presetGhagga={presetGhagga} />
-      )}
-      {stage === 'running' && (
-        <Progress
-          steps={steps}
-          projectName={projectName}
-          contextLine={`${projectName} (${stack} + ${ciProvider})`}
-          onDone={() => setStage('done')}
-        />
-      )}
-      {stage === 'done' && (
-        <Summary
-          steps={steps}
-          dryRun={dryRun}
-          projectName={projectName}
-          stack={stack}
-          elapsedMs={Date.now() - startTime}
-        />
-      )}
-    </Box>
-  )
-}

package/src/ui/CIContext.tsx

@@ -1,25 +0,0 @@
-import React, { createContext, useContext } from 'react'
-
-interface CIContextValue {
-  /** True when running in non-interactive mode (CI=1 or --no-tui) */
-  isCI: boolean
-}
-
-const CIContext = createContext<CIContextValue>({ isCI: false })
-
-export function useCIMode(): boolean {
-  return useContext(CIContext).isCI
-}
-
-interface Props {
-  isCI: boolean
-  children: React.ReactNode
-}
-
-export function CIProvider({ isCI, children }: Props) {
-  return (
-    <CIContext.Provider value={{ isCI }}>
-      {children}
-    </CIContext.Provider>
-  )
-}

package/src/ui/CISelector.tsx

@@ -1,72 +0,0 @@
-import React, { useState, useEffect } from 'react'
-import { Box, Text, useInput } from 'ink'
-import type { CIProvider } from '../types/index.js'
-import { theme } from './theme.js'
-import { useCIMode } from './CIContext.js'
-
-const CI_PROVIDERS: { id: CIProvider; label: string; description: string }[] = [
-  { id: 'github',     label: 'GitHub Actions', description: 'GitHub CI/CD with reusable workflows' },
-  { id: 'gitlab',     label: 'GitLab CI',      description: 'GitLab CI/CD pipelines' },
-  { id: 'woodpecker', label: 'Woodpecker CI',  description: 'Container-native CI for Gitea/Forgejo' },
-]
-
-interface Props {
-  onConfirm: (provider: CIProvider) => void
-}
-
-export default function CISelector({ onConfirm }: Props) {
-  const isCI = useCIMode()
-  const [cursor, setCursor] = useState(0)
-
-  // Auto-confirm in CI mode
-  useEffect(() => {
-    if (isCI) {
-      onConfirm(CI_PROVIDERS[cursor].id)
-    }
-  }, [isCI]) // eslint-disable-line react-hooks/exhaustive-deps
-
-  useInput((_, key) => {
-    if (key.upArrow)   setCursor(c => Math.max(0, c - 1))
-    if (key.downArrow) setCursor(c => Math.min(CI_PROVIDERS.length - 1, c + 1))
-    if (key.return) {
-      onConfirm(CI_PROVIDERS[cursor].id)
-    }
-  }, { isActive: !isCI })
-
-  return (
-    <Box flexDirection="column">
-      <Text bold>Select CI provider:</Text>
-
-      <Box
-        marginTop={1}
-        flexDirection="column"
-        borderStyle="single"
-        borderLeft
-        borderRight={false}
-        borderTop={false}
-        borderBottom={false}
-        borderColor={theme.muted}
-        paddingLeft={1}
-      >
-        {CI_PROVIDERS.map((p, i) => (
-          <Box key={p.id}>
-            <Text color={i === cursor ? theme.primary : 'white'}>
-              {i === cursor ? '\u25b6 ' : '  '}
-              {i === cursor ? '\u25c9' : '\u25cb'} {p.label}
-            </Text>
-            <Text color={theme.muted} dimColor>  {p.description}</Text>
-          </Box>
-        ))}
-      </Box>
-
-      <Box marginTop={1} gap={2}>
-        <Text color={theme.primary}>
-          {CI_PROVIDERS[cursor].label}
-        </Text>
-        <Text color={theme.muted} dimColor>
-          {'\u2191\u2193'} navigate  Enter confirm
-        </Text>
-      </Box>
-    </Box>
-  )
-}

package/src/ui/Doctor.tsx

@@ -1,122 +0,0 @@
-import React, { useEffect, useState, useCallback } from 'react'
-import { Box, Text, useApp, useInput } from 'ink'
-import Spinner from 'ink-spinner'
-import { runDoctor } from '../commands/doctor.js'
-import type { DoctorResult } from '../types/index.js'
-import Header from './Header.js'
-import { theme } from './theme.js'
-import { useCIMode } from './CIContext.js'
-
-type CheckStatus = 'ok' | 'fail' | 'skip'
-
-const STATUS_ICON: Record<CheckStatus, string> = {
-  ok:   '\u2713',
-  fail: '\u2717',
-  skip: '\u2013',
-}
-
-const STATUS_COLOR: Record<CheckStatus, string> = {
-  ok:   theme.success,
-  fail: theme.error,
-  skip: theme.muted,
-}
-
-export default function Doctor() {
-  const { exit } = useApp()
-  const isCI = useCIMode()
-  const [result, setResult] = useState<DoctorResult | null>(null)
-  const [error, setError] = useState<string | null>(null)
-  const [loading, setLoading] = useState(true)
-
-  const runCheck = useCallback(() => {
-    setLoading(true)
-    setResult(null)
-    setError(null)
-    runDoctor()
-      .then(r => { setResult(r); setLoading(false) })
-      .catch(e => { setError(String(e)); setLoading(false) })
-  }, [])
-
-  useEffect(() => { runCheck() }, [runCheck])
-
-  // Auto-exit in CI mode once loading finishes
-  useEffect(() => {
-    if (isCI && !loading) {
-      const t = setTimeout(() => exit(), 100)
-      return () => clearTimeout(t)
-    }
-    return undefined
-  }, [isCI, loading, exit])
-
-  useInput((input, key) => {
-    if (input.toLowerCase() === 'r') runCheck()
-    if (input.toLowerCase() === 'q' || key.return || key.escape) exit()
-  }, { isActive: !isCI })
-
-  // Compute health score
-  const allChecks = result?.sections.flatMap(s => s.checks) ?? []
-  const passed  = allChecks.filter(c => c.status === 'ok').length
-  const total   = allChecks.filter(c => c.status !== 'skip').length
-
-  return (
-    <Box flexDirection="column" padding={1}>
-      <Header subtitle="doctor" />
-
-      {loading && (
-        <Text color={theme.warning}>
-          <Spinner type="dots" />
-          {' Running checks...'}
-        </Text>
-      )}
-
-      {error && (
-        <Text color={theme.error}>{'\u2717'} Error: {error}</Text>
-      )}
-
-      {result && (
-        <Box flexDirection="column">
-          {/* Health score */}
-          <Box marginBottom={1}>
-            <Text bold>Health: </Text>
-            <Text bold color={passed === total ? theme.success : theme.warning}>
-              {passed}/{total} checks passed
-            </Text>
-          </Box>
-
-          {result.sections.map((section, si) => {
-            const sectionHasFail = section.checks.some(c => c.status === 'fail')
-            return (
-              <Box key={`section-${si}`} flexDirection="column" marginBottom={1}>
-                <Text bold color={sectionHasFail ? theme.warning : theme.success}>
-                  {'  '}{section.title}
-                </Text>
-                {section.checks.map((check, ci) => (
-                  <Box key={`${si}-check-${ci}`}>
-                    <Text color={STATUS_COLOR[check.status] as any}>
-                      {'  '}
-                      {STATUS_ICON[check.status]}
-                      {' '}
-                      {check.label}
-                      {check.detail
-                        ? <Text color={theme.muted} dimColor>{'  '}{check.detail}</Text>
-                        : null}
-                    </Text>
-                  </Box>
-                ))}
-              </Box>
-            )
-          })}
-        </Box>
-      )}
-
-      {/* Bottom hint */}
-      {!loading && (
-        <Box marginTop={1}>
-          <Text color={theme.muted} dimColor>
-            Press r to refresh, q to quit
-          </Text>
-        </Box>
-      )}
-    </Box>
-  )
-}

package/src/ui/Header.tsx

@@ -1,48 +0,0 @@
-import React from 'react'
-import { Box, Text } from 'ink'
-import { theme } from './theme.js'
-
-interface Props {
-  subtitle?: string
-  dryRun?: boolean
-}
-
-const TITLE = '\u2726 javi-forge  Project scaffolding'
-
-// Fixed inner width (characters between the box walls)
-const BOX_WIDTH = 41
-
-function pad(content: string): string {
-  const len = [...content].length  // unicode-safe length
-  const spaces = BOX_WIDTH - len
-  return content + ' '.repeat(Math.max(0, spaces))
-}
-
-export default function Header({ subtitle, dryRun }: Props) {
-  const top    = '\u256d' + '\u2500'.repeat(BOX_WIDTH) + '\u256e'
-  const bottom = '\u2570' + '\u2500'.repeat(BOX_WIDTH) + '\u256f'
-  const titleLine = pad('  ' + TITLE + '  ')
-  const subLine   = subtitle ? pad('  ' + subtitle + '  ') : null
-
-  return (
-    <Box flexDirection="column" marginBottom={1}>
-      <Text color={theme.muted}>{top}</Text>
-      <Box>
-        <Text color={theme.muted}>{'\u2502'}</Text>
-        <Text bold color={theme.primary}>{titleLine}</Text>
-        <Text color={theme.muted}>{'\u2502'}</Text>
-      </Box>
-      {subLine && (
-        <Box>
-          <Text color={theme.muted}>{'\u2502'}</Text>
-          <Text color={theme.muted}>{subLine}</Text>
-          <Text color={theme.muted}>{'\u2502'}</Text>
-        </Box>
-      )}
-      <Text color={theme.muted}>{bottom}</Text>
-      {dryRun && (
-        <Text color={theme.warning}> [DRY RUN]</Text>
-      )}
-    </Box>
-  )
-}