create-lore 0.1.0

package/bin/create-lore.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const TOOLS = ['Claude Code', 'Cursor', 'OpenCode'];
+const REPO_URL = 'https://github.com/lorehq/lore.git';
+
+async function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(question, answer => { rl.close(); resolve(answer); }));
+}
+
+async function selectTools() {
+  console.log('\nWhich AI coding tools will you use?\n');
+  TOOLS.forEach((t, i) => console.log(`  ${i + 1}. ${t}`));
+  console.log();
+  const answer = await prompt('Select tools (comma-separated numbers, e.g. 1,3): ');
+  const indices = answer.split(',').map(s => parseInt(s.trim(), 10) - 1);
+  const selected = indices.filter(i => i >= 0 && i < TOOLS.length).map(i => TOOLS[i]);
+  return selected.length > 0 ? selected : ['Claude Code'];
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const name = args.find(a => !a.startsWith('-'));
+  const templateDir = args.find((a, i) => args[i - 1] === '--template') || process.env.LORE_TEMPLATE;
+
+  if (!name) {
+    console.error('Usage: create-lore <name> [--template <path>]');
+    process.exit(1);
+  }
+
+  const isPath = name.includes('/') || name.includes(path.sep);
+  const targetDir = path.resolve(isPath ? name : `./lore-${name}`);
+
+  if (fs.existsSync(targetDir)) {
+    console.error(`Error: ${targetDir} already exists`);
+    process.exit(1);
+  }
+
+  // Clone or copy template
+  const tmpDir = path.join(require('os').tmpdir(), `create-lore-${Date.now()}`);
+  try {
+    if (templateDir) {
+      console.log(`Copying template from ${templateDir}...`);
+      copyDir(templateDir, tmpDir);
+    } else {
+      console.log(`Cloning ${REPO_URL}...`);
+      execSync(`git clone --depth 1 ${REPO_URL} "${tmpDir}"`, { stdio: 'pipe' });
+    }
+
+    // Remove .git from clone
+    const gitDir = path.join(tmpDir, '.git');
+    if (fs.existsSync(gitDir)) fs.rmSync(gitDir, { recursive: true });
+
+    // Copy to target
+    copyDir(tmpDir, targetDir);
+  } finally {
+    if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true });
+  }
+
+  // Select tools (skip in non-interactive mode)
+  let tools = ['Claude Code'];
+  if (process.stdin.isTTY) {
+    tools = await selectTools();
+  }
+
+  // Write .lore-config
+  const config = { name, tools, created: new Date().toISOString().split('T')[0] };
+  fs.writeFileSync(path.join(targetDir, '.lore-config'), JSON.stringify(config, null, 2) + '\n');
+
+  // Init git repo
+  execSync('git init', { cwd: targetDir, stdio: 'pipe' });
+
+  console.log(`\nCreated lore-${name} at ${targetDir}`);
+  console.log(`Tools: ${tools.join(', ')}`);
+  console.log(`\nNext steps:`);
+  console.log(`  cd ${targetDir}`);
+  console.log(`  git add -A && git commit -m "Init Lore"`);
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+main().catch(err => { console.error(err.message); process.exit(1); });

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "create-lore",
+  "version": "0.1.0",
+  "description": "Create a new Lore knowledge-persistent agent repo",
+  "bin": {
+    "create-lore": "bin/create-lore.js"
+  },
+  "scripts": {
+    "test": "node --test test/create-lore.test.js"
+  },
+  "keywords": ["lore", "agent", "ai", "knowledge"],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/test/create-lore.test.js

@@ -0,0 +1,92 @@
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const BIN = path.resolve(__dirname, '../bin/create-lore.js');
+const TEMPLATE = path.resolve(__dirname, '../../lore');
+const OUTPUT = path.resolve(__dirname, '../test-output');
+
+function run(args = '') {
+  return execSync(`node ${BIN} ${args}`, {
+    env: { ...process.env, LORE_TEMPLATE: TEMPLATE },
+    stdio: 'pipe',
+    encoding: 'utf8',
+  });
+}
+
+function cleanup() {
+  if (fs.existsSync(OUTPUT)) fs.rmSync(OUTPUT, { recursive: true });
+}
+
+describe('create-lore', () => {
+  before(cleanup);
+  after(cleanup);
+
+  it('exits with error when no name given', () => {
+    assert.throws(() => run(''), { status: 1 });
+  });
+
+  it('creates project directory with expected structure', () => {
+    const output = run(`${OUTPUT} --template ${TEMPLATE}`);
+
+    assert.ok(fs.existsSync(OUTPUT), 'output directory exists');
+
+    // .lore-config written with correct fields
+    const config = JSON.parse(fs.readFileSync(path.join(OUTPUT, '.lore-config'), 'utf8'));
+    assert.equal(config.name, OUTPUT);
+    assert.ok(Array.isArray(config.tools), 'tools is an array');
+    assert.ok(config.created, 'created date present');
+
+    // git repo initialized
+    assert.ok(fs.existsSync(path.join(OUTPUT, '.git')), 'git initialized');
+
+    // no template .git leaked
+    const entries = fs.readdirSync(path.join(OUTPUT, '.git'));
+    assert.ok(entries.includes('HEAD'), '.git looks like a fresh init');
+  });
+
+  it('fails if target directory already exists', () => {
+    fs.mkdirSync(OUTPUT, { recursive: true });
+    assert.throws(() => run(`${OUTPUT} --template ${TEMPLATE}`), /already exists/);
+    fs.rmSync(OUTPUT, { recursive: true });
+  });
+
+  // These tests activate as lore repo gets populated (Phase 2+)
+
+  it('has AGENTS.md when template provides it', () => {
+    const agentsMd = path.join(TEMPLATE, 'AGENTS.md');
+    if (!fs.existsSync(agentsMd)) return; // skip until Phase 2
+
+    run(`${OUTPUT} --template ${TEMPLATE}`);
+    assert.ok(fs.existsSync(path.join(OUTPUT, 'AGENTS.md')), 'AGENTS.md copied');
+    const content = fs.readFileSync(path.join(OUTPUT, 'AGENTS.md'), 'utf8');
+    assert.ok(content.length > 0, 'AGENTS.md is non-empty');
+    cleanup();
+  });
+
+  it('has hooks wired in .claude/settings.json when template provides it', () => {
+    const settings = path.join(TEMPLATE, '.claude/settings.json');
+    if (!fs.existsSync(settings)) return; // skip until Phase 3
+
+    run(`${OUTPUT} --template ${TEMPLATE}`);
+    const parsed = JSON.parse(fs.readFileSync(path.join(OUTPUT, '.claude/settings.json'), 'utf8'));
+    assert.ok(parsed.hooks, 'hooks key exists in settings');
+    cleanup();
+  });
+
+  it('passes validate-consistency.sh when template provides it', () => {
+    const script = path.join(TEMPLATE, 'scripts/validate-consistency.sh');
+    if (!fs.existsSync(script)) return; // skip until Phase 5
+
+    run(`${OUTPUT} --template ${TEMPLATE}`);
+    const result = execSync(`bash scripts/validate-consistency.sh`, {
+      cwd: OUTPUT,
+      encoding: 'utf8',
+      stdio: 'pipe',
+    });
+    assert.ok(result.includes('PASSED'), 'validation passes');
+    cleanup();
+  });
+});