create-lore 0.1.1 → 0.1.2

package/README.md

@@ -0,0 +1,38 @@
+# create-lore
+
+Create a new [Lore](https://github.com/lorehq/lore) knowledge-persistent AI coding framework repo.
+
+## Usage
+
+```bash
+npx create-lore myproject
+```
+
+This creates `lore-myproject/` with the full Lore framework — hooks, skills, scripts, and operating instructions that teach Claude Code to learn and remember across sessions.
+
+## What you get
+
+- **AGENTS.md / CLAUDE.md** — Operating instructions Claude Code reads automatically
+- **Hooks** — Session init, memory guard, post-action capture reminders
+- **Skills** — `create-skill` and `create-agent` for building your knowledge base
+- **Scripts** — Registry generation, agent generation, consistency validation
+
+## Options
+
+```bash
+npx create-lore myproject       # creates ./lore-myproject/
+npx create-lore ./custom-path   # creates at specific path
+```
+
+## After setup
+
+```bash
+cd lore-myproject
+git add -A && git commit -m "Init Lore"
+```
+
+Then open Claude Code in the project. The hooks will fire automatically and the self-learning loop begins.
+
+## License
+
+Apache-2.0

package/bin/create-lore.js

@@ -1,98 +1,69 @@
 #!/usr/bin/env node
 
+// create-lore: Bootstrap a new Lore knowledge-persistent agent repo.
+//
+// Usage: npx create-lore <name|path>
+//
+// How it works:
+//   1. Clones the Lore template from GitHub (or copies from LORE_TEMPLATE env var)
+//   2. Strips the template's .git history
+//   3. Writes a .lore-config with the project name and creation date
+//   4. Runs git init for a clean start
+//
+// The LORE_TEMPLATE env var is used by tests to point at a local template
+// directory instead of cloning from GitHub.
+
 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'];
+// -- Parse arguments --
+const name = process.argv[2];
+if (!name) {
+  console.error('Usage: create-lore <name>');
+  process.exit(1);
 }
 
-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' });
-    }
+// If the name contains a path separator, treat it as a custom path.
+// Otherwise, create a {name}/ directory in the current folder.
+const isPath = name.includes('/') || name.includes(path.sep);
+const targetDir = path.resolve(isPath ? name : `./${name}`);
 
-    // 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"`);
+if (fs.existsSync(targetDir)) {
+  console.error(`Error: ${targetDir} already exists`);
+  process.exit(1);
 }
 
-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);
-    }
+// -- Copy template to target --
+// Clone from GitHub or copy from a local template directory.
+// Uses a temp dir so we can strip .git before copying to the final location.
+const tmpDir = path.join(require('os').tmpdir(), `create-lore-${Date.now()}`);
+try {
+  const templateDir = process.env.LORE_TEMPLATE;
+  if (templateDir) {
+    fs.cpSync(templateDir, tmpDir, { recursive: true });
+  } else {
+    execSync(`git clone --depth 1 ${REPO_URL} "${tmpDir}"`, { stdio: 'pipe' });
   }
+  fs.rmSync(path.join(tmpDir, '.git'), { recursive: true, force: true });
+  fs.cpSync(tmpDir, targetDir, { recursive: true });
+} finally {
+  // Always clean up the temp dir
+  if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true });
 }
 
-main().catch(err => { console.error(err.message); process.exit(1); });
+// -- Write .lore-config --
+const projectName = isPath ? path.basename(targetDir) : name;
+const config = { name: projectName, created: new Date().toISOString().split('T')[0] };
+fs.writeFileSync(path.join(targetDir, '.lore-config'), JSON.stringify(config, null, 2) + '\n');
+
+// -- Initialize git --
+execSync('git init', { cwd: targetDir, stdio: 'pipe' });
+
+// -- Done --
+console.log(`\nCreated ${targetDir}`);
+console.log(`\nNext steps:`);
+console.log(`  cd ${targetDir}`);
+console.log(`  git add -A && git commit -m "Init Lore"`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-lore",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Create a new Lore knowledge-persistent agent repo",
   "bin": {
     "create-lore": "bin/create-lore.js"

package/test/create-lore.test.js

@@ -1,3 +1,7 @@
+// Tests for create-lore installer.
+// Uses the local lore repo (sibling directory) as the template via LORE_TEMPLATE env var.
+// Runs the installer in a subprocess and validates the output directory structure.
+
 const { describe, it, before, after } = require('node:test');
 const assert = require('node:assert/strict');
 const { execSync } = require('child_process');
@@ -5,9 +9,10 @@ const fs = require('fs');
 const path = require('path');
 
 const BIN = path.resolve(__dirname, '../bin/create-lore.js');
-const TEMPLATE = path.resolve(__dirname, '../../lore');
+const TEMPLATE = path.resolve(__dirname, '../../lore'); // Sibling lore repo
 const OUTPUT = path.resolve(__dirname, '../test-output');
 
+// Run the installer with LORE_TEMPLATE pointing at the local template
 function run(args = '') {
   return execSync(`node ${BIN} ${args}`, {
     env: { ...process.env, LORE_TEMPLATE: TEMPLATE },
@@ -29,59 +34,54 @@ describe('create-lore', () => {
   });
 
   it('creates project directory with expected structure', () => {
-    const output = run(`${OUTPUT} --template ${TEMPLATE}`);
+    run(OUTPUT);
 
     assert.ok(fs.existsSync(OUTPUT), 'output directory exists');
 
-    // .lore-config written with correct fields
+    // .lore-config has required 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.name, 'name present');
     assert.ok(config.created, 'created date present');
 
-    // git repo initialized
+    // Fresh git repo initialized (not cloned template history)
     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/);
+    assert.throws(() => run(OUTPUT), /already exists/);
     fs.rmSync(OUTPUT, { recursive: true });
   });
 
-  // These tests activate as lore repo gets populated (Phase 2+)
+  // -- Template content tests --
+  // These skip gracefully if the template hasn't reached that phase yet.
 
-  it('has AGENTS.md when template provides it', () => {
-    const agentsMd = path.join(TEMPLATE, 'AGENTS.md');
-    if (!fs.existsSync(agentsMd)) return; // skip until Phase 2
+  it('has CLAUDE.md when template provides it', () => {
+    if (!fs.existsSync(path.join(TEMPLATE, 'CLAUDE.md'))) return;
 
-    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');
+    run(OUTPUT);
+    assert.ok(fs.existsSync(path.join(OUTPUT, 'CLAUDE.md')), 'CLAUDE.md copied');
+    const content = fs.readFileSync(path.join(OUTPUT, 'CLAUDE.md'), 'utf8');
+    assert.ok(content.length > 0, 'CLAUDE.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
+    if (!fs.existsSync(path.join(TEMPLATE, '.claude/settings.json'))) return;
 
-    run(`${OUTPUT} --template ${TEMPLATE}`);
+    run(OUTPUT);
     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
+    if (!fs.existsSync(path.join(TEMPLATE, 'scripts/validate-consistency.sh'))) return;
 
-    run(`${OUTPUT} --template ${TEMPLATE}`);
-    const result = execSync(`bash scripts/validate-consistency.sh`, {
+    run(OUTPUT);
+    const result = execSync('bash scripts/validate-consistency.sh', {
       cwd: OUTPUT,
       encoding: 'utf8',
       stdio: 'pipe',