javi-forge 0.1.0

package/src/types/index.ts

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,175 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,122 @@
+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

@@ -0,0 +1,48 @@
+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>
+  )
+}